#include "sandboxed_api/sandbox2/syscall_defs.h"

#include <arpa/inet.h>
#include <dirent.h>
#include <linux/netlink.h>
#include <netdb.h>
#include <netinet/in.h>
#include <pwd.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>

#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>

#include "absl/algorithm/container.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/escaping.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
#include "sandboxed_api/config.h"
#include "sandboxed_api/sandbox2/util.h"
#include "sandboxed_api/util/status_macros.h"

namespace sandbox2 {

namespace syscalls {

absl::StatusOr<std::string> syscalls::ArgData::GetDescriptionImpl() const {
  std::string formatted;
  switch (type_) {
    case kPath: {
      SAPI_ASSIGN_OR_RETURN(std::string str, ReadAsString());
      formatted = absl::StrFormat("'%s'", absl::CHexEscape(str));
      break;
    }
    case kString: {
      SAPI_ASSIGN_OR_RETURN(std::string str, ReadAsString());
      formatted = absl::StrFormat("\"%s\"", absl::CHexEscape(str));
      break;
    }
    case kFlags:
      formatted = absl::StrFormat("\\0%o", value_);
      break;
    case kSignal:
      formatted = util::GetSignalName(value_);
      break;
    case kAddressFamily:
      formatted = util::GetAddressFamily(value_);
      break;
    case kSubcommand:
    case kInt:
    case kResource:
    case kIpcResource:
    case kPid:
    case kGid:
    case kUid:
    case kLen0:
    case kLen1:
    case kLen2:
    case kLen3:
    case kLen4:
    case kLen5:
      formatted = absl::StrCat(value_);
      break;
    case kPollFdArray:
    case kSockaddr:
    case kGen:
    case kStruct:
    case kPtr:
    case kArray:
    case kSharedAddress:
    case kGidArray:
      break;
    default:
      return absl::InternalError("Unable to format invalid type");
  }

  if (formatted.empty()) {
    return absl::StrFormat("%#x", value_);
  }
  return absl::StrFormat("%#x [%s]", value_, formatted);
}

std::string ArgData::GetDescription() const {
  return GetDescriptionImpl().value_or(
      absl::StrFormat("%#x [unavailable]", value_));
}

}  // namespace syscalls

absl::string_view SyscallTable::GetName(int syscall) const {
  absl::StatusOr<SyscallTable::Entry> entry = GetEntry(syscall);
  if (!entry.ok()) {
    return "";
  }
  return entry->name;
}

namespace {

template <typename... ArgTypes>
constexpr SyscallTable::Entry MakeEntry(int nr, absl::string_view name,
                                        ArgTypes... arg_types) {
  static_assert(sizeof...(arg_types) <= syscalls::kMaxArgs,
                "Too many arguments for syscall");
  return {nr, name, sizeof...(arg_types), {arg_types...}};
}

struct UnknownArguments {};
constexpr SyscallTable::Entry MakeEntry(int nr, absl::string_view name,
                                        UnknownArguments) {
  return {nr,
          name,
          -1,
          {syscalls::kGen, syscalls::kGen, syscalls::kGen, syscalls::kGen,
           syscalls::kGen, syscalls::kGen}};
}

}  // namespace

absl::StatusOr<SyscallTable::Entry> SyscallTable::GetEntry(int syscall) const {
  auto it = absl::c_lower_bound(
      data_, syscall, [](const SyscallTable::Entry& entry, int syscall) {
        return entry.nr < syscall;
      });
  if (it == data_.end() || it->nr != syscall) {
    return absl::NotFoundError(absl::StrCat("Syscall not found: ", syscall));
  }
  return *it;
}

absl::StatusOr<SyscallTable::Entry> SyscallTable::GetEntry(
    absl::string_view name) const {
  // Note: There's no uniqueness guarantee of syscall names in the table, but
  // other than typos it's likely safe to assume uniqueness.
  auto filter = [name](const SyscallTable::Entry& entry) {
    return entry.name == name;
  };
  auto it = absl::c_find_if(data_, filter);
  if (it != data_.end()) {
    return *it;
  } else {
    return absl::NotFoundError(absl::StrCat("Name not found: ", name));
  }
}

constexpr SyscallTable::Entry kInvalidEntry =
    MakeEntry(-1, "unknown_syscall", UnknownArguments());

std::vector<syscalls::ArgData> SyscallTable::GetArgumentsData(
    int syscall, const uint64_t values[], pid_t pid) const {
  SyscallTable::Entry entry = GetEntry(syscall).value_or(kInvalidEntry);
  // First do a length scan.
  std::array<std::optional<uint64_t>, syscalls::kMaxArgs> lengths;
  for (int i = 0; i < entry.GetNumArgs(); ++i) {
    syscalls::ArgType type = entry.arg_types[i];
    if (type == syscalls::kLen0) {
      lengths[0] = values[i];
    } else if (type == syscalls::kLen1) {
      lengths[1] = values[i];
    } else if (type == syscalls::kLen2) {
      lengths[2] = values[i];
    } else if (type == syscalls::kLen3) {
      lengths[3] = values[i];
    } else if (type == syscalls::kLen4) {
      lengths[4] = values[i];
    } else if (type == syscalls::kLen5) {
      lengths[5] = values[i];
    }
  }

  // Then get all verbose descriptions, passing the correct lengths where used.
  std::vector<syscalls::ArgData> args;
  for (int i = 0; i < entry.GetNumArgs(); ++i) {
    const syscalls::ArgType type = entry.arg_types[i];
    args.push_back(syscalls::ArgData(type, pid, values[i], lengths[i]));
  }

  return args;
}

std::vector<std::string> SyscallTable::GetArgumentsDescription(
    int syscall, const uint64_t values[], pid_t pid) const {
  std::vector<std::string> descriptions;
  for (const syscalls::ArgData& arg : GetArgumentsData(syscall, values, pid)) {
    descriptions.push_back(arg.GetDescription());
  }
  return descriptions;
}

namespace syscalls {
namespace {

// TODO(C++20) Use std::is_sorted
template <typename Container, typename Compare>
constexpr bool IsSorted(const Container& container, Compare comp) {
  auto it = std::begin(container);
  if (it == std::end(container)) {
    return true;
  }
  auto last = it;
  for (++it; it != std::end(container); ++it) {
    if (!comp(*last, *it)) {
      return false;
    }
    last = it;
  }
  return true;
}

// Syscall description table for Linux x86_64
constexpr std::array kSyscallDataX8664 = {
    // clang-format off
    MakeEntry(0, "read", kResource, kArray, kLen1),
    MakeEntry(1, "write", kResource, kArray, kLen1),
    MakeEntry(2, "open", kPath, kFlags, kFlags),
    MakeEntry(3, "close", kResource),
    MakeEntry(4, "stat", kPath, kPtr),
    MakeEntry(5, "fstat", kResource, kPtr),
    MakeEntry(6, "lstat", kPath, kPtr),
    MakeEntry(7, "poll", kPollFdArray, kLen0, kInt),
    MakeEntry(8, "lseek", kResource, kInt, kFlags),
    MakeEntry(9, "mmap", kPtr, kLen0, kFlags, kFlags, kResource, kInt),
    MakeEntry(10, "mprotect", kPtr, kLen0, kFlags),
    MakeEntry(11, "munmap", kPtr, kLen0),
    MakeEntry(12, "brk", kInt),
    MakeEntry(13, "rt_sigaction", kSignal, kPtr, kPtr, kLen4, kPtr),
    MakeEntry(14, "rt_sigprocmask", kFlags, kPtr, kPtr, kLen1),
    MakeEntry(15, "rt_sigreturn"),
    MakeEntry(16, "ioctl", kResource, kSubcommand, kArray),
    MakeEntry(17, "pread64", kResource, kArray, kLen1, kInt),
    MakeEntry(18, "pwrite64", kResource, kArray, kLen1, kInt),
    MakeEntry(19, "readv", kResource, kArray, kLen1),
    MakeEntry(20, "writev", kResource, kArray, kLen1),
    MakeEntry(21, "access", kPath, kFlags),
    MakeEntry(22, "pipe", kPtr),
    MakeEntry(23, "select", kLen1, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(24, "sched_yield"),
    MakeEntry(25, "mremap", kPtr, kLen0, kLen4, kFlags, kPtr),
    MakeEntry(26, "msync", kPtr, kLen0, kFlags),
    MakeEntry(27, "mincore", kPtr, kLen0, kArray),
    MakeEntry(28, "madvise", kPtr, kLen0, kFlags),
    MakeEntry(29, "shmget", kInt, kLen3, kFlags, kPtr),
    MakeEntry(30, "shmat", kIpcResource, kPtr, kFlags),
    MakeEntry(31, "shmctl", kIpcResource, kSubcommand, kArray),
    MakeEntry(32, "dup", kResource),
    MakeEntry(33, "dup2", kResource, kResource),
    MakeEntry(34, "pause"),
    MakeEntry(35, "nanosleep", kPtr, kPtr),
    MakeEntry(36, "getitimer", kFlags, kPtr),
    MakeEntry(37, "alarm", kInt),
    MakeEntry(38, "setitimer", kFlags, kPtr, kPtr),
    MakeEntry(39, "getpid"),
    MakeEntry(40, "sendfile", kResource, kResource, kPtr, kInt),
    MakeEntry(41, "socket", kFlags, kFlags, kInt),
    MakeEntry(42, "connect", kResource, kSockaddr, kLen1),
    MakeEntry(43, "accept", kResource, kPtr, kPtr),
    MakeEntry(44, "sendto", kResource, kArray, kLen1, kFlags, kSockaddr, kLen4),
    MakeEntry(45, "recvfrom", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(46, "sendmsg", kResource, kPtr, kFlags),
    MakeEntry(47, "recvmsg", kResource, kPtr, kFlags),
    MakeEntry(48, "shutdown", kResource, kFlags),
    MakeEntry(49, "bind", kResource, kSockaddr, kLen1),
    MakeEntry(50, "listen", kResource, kInt),
    MakeEntry(51, "getsockname", kResource, kPtr, kPtr),
    MakeEntry(52, "getpeername", kResource, kPtr, kPtr),
    MakeEntry(53, "socketpair", kFlags, kFlags, kInt, kPtr),
    MakeEntry(54, "setsockopt", kResource, kFlags, kFlags, kArray, kLen3),
    MakeEntry(55, "getsockopt", kResource, kInt, kInt, kArray, kPtr),
    MakeEntry(56, "clone", kFlags, kArray, kPtr, kPtr, kArray),
    MakeEntry(57, "fork"),
    MakeEntry(58, "vfork"),
    MakeEntry(59, "execve", kPath, kArray, kArray),
    MakeEntry(60, "exit", kInt),
    MakeEntry(61, "wait4", kPid, kPtr, kFlags, kPtr),
    MakeEntry(62, "kill", kPid, kSignal),
    MakeEntry(63, "uname", kArray),
    MakeEntry(64, "semget", kIpcResource, kFlags, kFlags),
    MakeEntry(65, "semop", kIpcResource, kArray, kLen1),
    MakeEntry(66, "semctl", kIpcResource, kFlags, kSubcommand, kArray),
    MakeEntry(67, "shmdt", kSharedAddress),
    MakeEntry(68, "msgget", kIpcResource, kFlags),
    MakeEntry(69, "msgsnd", kIpcResource, kPtr, kLen1, kFlags),
    MakeEntry(70, "msgrcv", kIpcResource, kPtr, kLen1, kFlags, kFlags),
    MakeEntry(71, "msgctl", kIpcResource, kSubcommand, kArray),
    MakeEntry(72, "fcntl", kResource, kSubcommand, kResource),
    MakeEntry(73, "flock", kResource, kFlags),
    MakeEntry(74, "fsync", kResource),
    MakeEntry(75, "fdatasync", kResource),
    MakeEntry(76, "truncate", kPath, kInt),
    MakeEntry(77, "ftruncate", kResource, kInt),
    MakeEntry(78, "getdents", kResource, kArray, kLen1),
    MakeEntry(79, "getcwd", kArray, kLen0),
    MakeEntry(80, "chdir", kPath),
    MakeEntry(81, "fchdir", kResource),
    MakeEntry(82, "rename", kPath, kPath),
    MakeEntry(83, "mkdir", kPath, kFlags),
    MakeEntry(84, "rmdir", kPath),
    MakeEntry(85, "creat", kPath, kFlags),
    MakeEntry(86, "link", kPath, kPath),
    MakeEntry(87, "unlink", kPath),
    MakeEntry(88, "symlink", kPath, kPath),
    MakeEntry(89, "readlink", kPath, kArray, kLen1),
    MakeEntry(90, "chmod", kPath, kFlags),
    MakeEntry(91, "fchmod", kResource, kFlags),
    MakeEntry(92, "chown", kPath, kUid, kGid),
    MakeEntry(93, "fchown", kResource, kUid, kGid),
    MakeEntry(94, "lchown", kPath, kUid, kGid),
    MakeEntry(95, "umask", kFlags),
    MakeEntry(96, "gettimeofday", kPtr, kPtr),
    MakeEntry(97, "getrlimit", kFlags, kPtr),
    MakeEntry(98, "getrusage", kFlags, kPtr),
    MakeEntry(99, "sysinfo", kArray),
    MakeEntry(100, "times", kPtr),
    MakeEntry(101, "ptrace", kFlags, kPid),
    MakeEntry(102, "getuid"),
    MakeEntry(103, "syslog", kSubcommand, kArray, kLen1),
    MakeEntry(104, "getgid"),
    MakeEntry(105, "setuid", kUid),
    MakeEntry(106, "setgid", kGid),
    MakeEntry(107, "geteuid"),
    MakeEntry(108, "getegid"),
    MakeEntry(109, "setpgid", kPid, kPid),
    MakeEntry(110, "getppid"),
    MakeEntry(111, "getpgrp", kPid),
    MakeEntry(112, "setsid"),
    MakeEntry(113, "setreuid", kUid, kUid),
    MakeEntry(114, "setregid", kGid, kGid),
    MakeEntry(115, "getgroups", kLen1, kGidArray),
    MakeEntry(116, "setgroups", kLen1, kGidArray),
    MakeEntry(117, "setresuid", kUid, kUid, kUid),
    MakeEntry(118, "getresuid", kPtr, kPtr, kPtr),
    MakeEntry(119, "setresgid", kGid, kGid, kGid),
    MakeEntry(120, "getresgid", kPtr, kPtr, kPtr),
    MakeEntry(121, "getpgid", kPid),
    MakeEntry(122, "setfsuid", kUid),
    MakeEntry(123, "setfsgid", kGid),
    MakeEntry(124, "getsid", kPid),
    MakeEntry(125, "capget", kPtr, kPtr),
    MakeEntry(126, "capset", kPtr, kPtr),
    MakeEntry(127, "rt_sigpending", kPtr, kLen0),
    MakeEntry(128, "rt_sigtimedwait", kPtr, kPtr, kPtr, kLen0),
    MakeEntry(129, "rt_sigqueueinfo", kPid, kSignal, kPtr),
    MakeEntry(130, "rt_sigsuspend", kPtr, kLen0),
    MakeEntry(131, "sigaltstack", kPtr, kPtr),
    MakeEntry(132, "utime", kPath, kPtr),
    MakeEntry(133, "mknod", kPath, kFlags, kInt),
    MakeEntry(134, "uselib", kPath),
    MakeEntry(135, "personality", kFlags),
    MakeEntry(136, "ustat", kInt, kPtr),
    MakeEntry(137, "statfs", kPath, kArray),
    MakeEntry(138, "fstatfs", kResource, kArray),
    MakeEntry(139, "sysfs", kInt, kString),
    MakeEntry(140, "getpriority", kFlags, kPid),
    MakeEntry(141, "setpriority", kFlags, kPid, kInt),
    MakeEntry(142, "sched_setparam", kPid, kPtr),
    MakeEntry(143, "sched_getparam", kPid, kPtr),
    MakeEntry(144, "sched_setscheduler", kPid, kFlags, kPtr),
    MakeEntry(145, "sched_getscheduler", kPid),
    MakeEntry(146, "sched_get_priority_max", kInt),
    MakeEntry(147, "sched_get_priority_min", kInt),
    MakeEntry(148, "sched_rr_get_interval", kPid, kPtr),
    MakeEntry(149, "mlock", kPtr, kLen0),
    MakeEntry(150, "munlock", kPtr, kLen0),
    MakeEntry(151, "mlockall", kFlags),
    MakeEntry(152, "munlockall"),
    MakeEntry(153, "vhangup"),
    MakeEntry(154, "modify_ldt", kInt, kPtr, kLen1),
    MakeEntry(155, "pivot_root", kPath, kPath),
    MakeEntry(156, "_sysctl", kPtr),
    MakeEntry(157, "prctl", kSubcommand, kSubcommand, kInt, kInt, kInt),
    MakeEntry(158, "arch_prctl", kSubcommand, kInt),
    MakeEntry(159, "adjtimex", kArray),
    MakeEntry(160, "setrlimit", kFlags, kPtr),
    MakeEntry(161, "chroot", kPath),
    MakeEntry(162, "sync"),
    MakeEntry(163, "acct", kPath),
    MakeEntry(164, "settimeofday", kPtr, kPtr),
    MakeEntry(165, "mount", kPtr, kPath, kString, kFlags, kString),
    MakeEntry(166, "umount2", kPath, kFlags),
    MakeEntry(167, "swapon", kPath, kFlags),
    MakeEntry(168, "swapoff", kPath),
    MakeEntry(169, "reboot", kInt, kInt, kSubcommand, kPtr),
    MakeEntry(170, "sethostname", kString, kLen0),
    MakeEntry(171, "setdomainname", kString, kLen0),
    MakeEntry(172, "iopl", kInt),
    MakeEntry(173, "ioperm", kInt, kInt, kInt),
    MakeEntry(174, "create_module", kString, kInt),
    MakeEntry(175, "init_module", kString, kLen0, kString),
    MakeEntry(176, "delete_module", kString, kFlags),
    MakeEntry(177, "get_kernel_syms", kInt),
    MakeEntry(178, "query_module", kString, kInt, kGen, kInt, kGen),
    MakeEntry(179, "quotactl", kSubcommand, kPath, kInt, kGen),
    MakeEntry(180, "nfsservctl", kSubcommand, kPtr, kPtr),
    MakeEntry(181, "getpmsg", UnknownArguments()),      // Not implemented.
    MakeEntry(182, "putpmsg", UnknownArguments()),      // Not implemented.
    MakeEntry(183, "afs_syscall", UnknownArguments()),  // Not implemented.
    MakeEntry(184, "tuxcall", UnknownArguments()),      // Not implemented.
    MakeEntry(185, "security", UnknownArguments()),     // Not implemented.
    MakeEntry(186, "gettid"),
    MakeEntry(187, "readahead", kResource, kInt, kInt),
    MakeEntry(188, "setxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(189, "lsetxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(190, "fsetxattr", kResource, kPtr, kString, kLen2, kFlags),
    MakeEntry(191, "getxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(192, "lgetxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(193, "fgetxattr", kResource, kPtr, kArray, kLen2),
    MakeEntry(194, "listxattr", kPath, kArray, kLen1),
    MakeEntry(195, "llistxattr", kPath, kArray, kLen1),
    MakeEntry(196, "flistxattr", kResource, kArray, kLen1),
    MakeEntry(197, "removexattr", kPath, kPtr),
    MakeEntry(198, "lremovexattr", kPath, kPtr),
    MakeEntry(199, "fremovexattr", kResource, kPtr),
    MakeEntry(200, "tkill", kPid, kSignal),
    MakeEntry(201, "time", kPtr),
    MakeEntry(202, "futex", kPtr, kFlags, kInt, kPtr, kPtr, kInt),
    MakeEntry(203, "sched_setaffinity", kPid, kLen2, kPtr),
    MakeEntry(204, "sched_getaffinity", kPid, kLen2, kPtr),
    MakeEntry(205, "set_thread_area", kPtr),
    MakeEntry(206, "io_setup", kInt, kPtr),
    MakeEntry(207, "io_destroy", kStruct),
    MakeEntry(208, "io_getevents", kStruct, kInt, kLen3, kArray, kPtr),
    MakeEntry(209, "io_submit", kStruct, kLen2, kArray),
    MakeEntry(210, "io_cancel", kStruct, kPtr, kPtr),
    MakeEntry(211, "get_thread_area", kPtr),
    MakeEntry(212, "lookup_dcookie", kInt, kArray, kLen1),
    MakeEntry(213, "epoll_create", kInt),
    MakeEntry(214, "epoll_ctl_old", UnknownArguments()),   // Not implemented.
    MakeEntry(215, "epoll_wait_old", UnknownArguments()),  // Not implemented.
    MakeEntry(216, "remap_file_pages", kPtr, kLen0, kFlags, kInt, kFlags),
    MakeEntry(217, "getdents64", kResource, kArray, kLen1),
    MakeEntry(218, "set_tid_address", kPtr),
    MakeEntry(219, "restart_syscall"),
    MakeEntry(220, "semtimedop", kIpcResource, kArray, kLen1, kPtr),
    MakeEntry(221, "fadvise64", kResource, kInt, kInt, kFlags),
    MakeEntry(222, "timer_create", kFlags, kPtr, kPtr),
    MakeEntry(223, "timer_settime", kStruct, kFlags, kPtr, kPtr),
    MakeEntry(224, "timer_gettime", kStruct, kPtr),
    MakeEntry(225, "timer_getoverrun", kStruct),
    MakeEntry(226, "timer_delete", kStruct),
    MakeEntry(227, "clock_settime", kFlags, kPtr),
    MakeEntry(228, "clock_gettime", kFlags, kPtr),
    MakeEntry(229, "clock_getres", kFlags, kPtr),
    MakeEntry(230, "clock_nanosleep", kFlags, kFlags, kPtr, kPtr),
    MakeEntry(231, "exit_group", kInt),
    MakeEntry(232, "epoll_wait", kResource, kArray, kLen1, kInt),
    MakeEntry(233, "epoll_ctl", kResource, kInt, kResource, kPtr),
    MakeEntry(234, "tgkill", kPid, kPid, kSignal),
    MakeEntry(235, "utimes", kPath, kPtr),
    MakeEntry(236, "vserver", UnknownArguments()),  // Not implemented.
    MakeEntry(237, "mbind", kPtr, kLen0, kFlags, kPtr, kInt, kFlags),
    MakeEntry(238, "set_mempolicy", kFlags, kPtr, kInt),
    MakeEntry(239, "get_mempolicy", kPtr, kPtr, kInt, kPtr, kFlags),
    MakeEntry(240, "mq_open", kString, kFlags, kFlags, kPtr),
    MakeEntry(241, "mq_unlink", kString),
    MakeEntry(242, "mq_timedsend", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(243, "mq_timedreceive", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(244, "mq_notify", kResource, kPtr),
    MakeEntry(245, "mq_getsetattr", kResource, kPtr, kPtr),
    MakeEntry(246, "kexec_load", kInt, kLen2, kArray, kFlags),
    MakeEntry(247, "waitid", kFlags, kPid, kPtr, kFlags, kPtr),
    MakeEntry(248, "add_key", kString, kPtr, kArray, kLen2, kStruct),
    MakeEntry(249, "request_key", kString, kPtr, kString, kStruct),
    MakeEntry(250, "keyctl", kInt, kInt, kInt, kInt, kInt),
    MakeEntry(251, "ioprio_set", kFlags, kPid, kFlags),
    MakeEntry(252, "ioprio_get", kFlags, kUid),
    MakeEntry(253, "inotify_init"),
    MakeEntry(254, "inotify_add_watch", kResource, kPath, kFlags),
    MakeEntry(255, "inotify_rm_watch", kResource, kResource),
    MakeEntry(256, "migrate_pages", kPid, kInt, kPtr, kPtr),
    MakeEntry(257, "openat", kResource, kPath, kFlags, kFlags),
    MakeEntry(258, "mkdirat", kResource, kPath, kFlags),
    MakeEntry(259, "mknodat", kResource, kPath, kFlags, kInt),
    MakeEntry(260, "fchownat", kResource, kPath, kUid, kGid, kFlags),
    MakeEntry(261, "futimesat", kResource, kPath, kPtr),
    MakeEntry(262, "newfstatat", kInt, kPath, kPtr, kFlags),
    MakeEntry(263, "unlinkat", kResource, kPath, kFlags),
    MakeEntry(264, "renameat", kResource, kPath, kResource, kPath),
    MakeEntry(265, "linkat", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(266, "symlinkat", kPath, kResource, kPath),
    MakeEntry(267, "readlinkat", kResource, kPath, kArray, kLen2),
    MakeEntry(268, "fchmodat", kResource, kPath, kFlags),
    MakeEntry(269, "faccessat", kResource, kPath, kFlags),
    MakeEntry(270, "pselect6", kLen1, kPtr, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(271, "ppoll", kPollFdArray, kLen0, kPtr, kPtr, kLen3),
    MakeEntry(272, "unshare", kFlags),
    MakeEntry(273, "set_robust_list", kPtr, kLen0),
    MakeEntry(274, "get_robust_list", kPid, kPtr, kPtr),
    MakeEntry(275, "splice", kResource, kPtr, kResource, kPtr, kInt, kFlags),
    MakeEntry(276, "tee", kResource, kResource, kInt, kFlags),
    MakeEntry(277, "sync_file_range", kResource, kInt, kInt, kFlags),
    MakeEntry(278, "vmsplice", kResource, kArray, kLen1, kFlags),
    MakeEntry(279, "move_pages", kPid, kLen2, kArray, kArray, kArray, kFlags),
    MakeEntry(280, "utimensat", kResource, kPath, kPtr, kFlags),
    MakeEntry(281, "epoll_pwait", kResource, kArray, kLen1, kInt, kPtr, kLen4),
    MakeEntry(282, "signalfd", kResource, kPtr, kLen1),
    MakeEntry(283, "timerfd_create", kFlags, kFlags),
    MakeEntry(284, "eventfd", kInt),
    MakeEntry(285, "fallocate", kResource, kFlags, kInt, kInt),
    MakeEntry(286, "timerfd_settime", kResource, kFlags, kPtr, kPtr),
    MakeEntry(287, "timerfd_gettime", kResource, kPtr),
    MakeEntry(288, "accept4", kResource, kPtr, kPtr, kFlags),
    MakeEntry(289, "signalfd4", kResource, kPtr, kLen1, kFlags),
    MakeEntry(290, "eventfd2", kInt, kFlags),
    MakeEntry(291, "epoll_create1", kFlags),
    MakeEntry(292, "dup3", kResource, kResource, kFlags),
    MakeEntry(293, "pipe2", kPtr, kFlags),
    MakeEntry(294, "inotify_init1", kFlags),
    MakeEntry(295, "preadv", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(296, "pwritev", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(297, "rt_tgsigqueueinfo", kPid, kPid, kSignal, kPtr),
    MakeEntry(298, "perf_event_open", kPtr, kPid, kInt, kResource, kFlags),
    MakeEntry(299, "recvmmsg", kResource, kArray, kLen1, kFlags, kPtr),
    MakeEntry(300, "fanotify_init", kFlags, kFlags),
    MakeEntry(301, "fanotify_mark", kResource, kFlags, kFlags, kResource,
              kPath),
    MakeEntry(302, "prlimit64", kPid, kFlags, kPtr, kPtr),
    MakeEntry(303, "name_to_handle_at", kResource, kPath, kPtr, kPtr, kFlags),
    MakeEntry(304, "open_by_handle_at", kResource, kPtr, kFlags),
    MakeEntry(305, "clock_adjtime", kFlags, kPtr),
    MakeEntry(306, "syncfs", kResource),
    MakeEntry(307, "sendmmsg", kResource, kArray, kLen1, kFlags),
    MakeEntry(308, "setns", kResource, kFlags),
    MakeEntry(309, "getcpu", kPtr, kPtr),
    MakeEntry(310, "process_vm_readv", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(311, "process_vm_writev", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(312, "kcmp", kPid, kPid, kFlags, kResource, kResource),
    MakeEntry(313, "finit_module", kResource, kString, kFlags),
    MakeEntry(314, "sched_setattr", kPid, kPtr, kInt),
    MakeEntry(315, "sched_getattr", kPid, kPtr, kLen1, kInt),
    MakeEntry(316, "renameat2", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(317, "seccomp", kInt, kFlags, kPtr),
    MakeEntry(318, "getrandom", kArray, kLen0, kFlags),
    MakeEntry(319, "memfd_create", kString, kFlags),
    MakeEntry(320, "kexec_file_load", kInt, kInt, kInt, kString, kInt),
    MakeEntry(321, "bpf", kSubcommand, kPtr, kLen1),
    MakeEntry(322, "execveat", kResource, kPath, kArray, kArray, kFlags),
    MakeEntry(323, "userfaultfd", kFlags),
    MakeEntry(324, "membarrier", kSubcommand, kFlags),
    MakeEntry(325, "mlock2", kPtr, kLen0, kFlags),
    MakeEntry(326, "copy_file_range", kResource, kPtr, kResource, kPtr, kInt,
              kFlags),
    MakeEntry(327, "preadv2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(328, "pwritev2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(329, "pkey_mprotect", kPtr, kLen0, kFlags, kInt),
    MakeEntry(330, "pkey_alloc", kInt, kFlags),
    MakeEntry(331, "pkey_free", kInt),
    MakeEntry(332, "statx", kResource, kPath, kFlags, kFlags, kPtr),
    MakeEntry(333, "io_pgetevents", kStruct, kInt, kLen3, kArray, kPtr, kPtr),
    MakeEntry(334, "rseq", kPtr, kLen0, kFlags, kInt),
    MakeEntry(335, "uretprobe"),
    MakeEntry(424, "pidfd_send_signal", kResource, kInt, kPtr, kFlags),
    MakeEntry(425, "io_uring_setup", kInt, kPtr),
    MakeEntry(426, "io_uring_enter", kResource, kInt, kInt, kFlags, kPtr,
              kLen4),
    MakeEntry(427, "io_uring_register", kResource, kInt, kPtr, kLen3),
    MakeEntry(428, "open_tree", kResource, kPath, kFlags),
    MakeEntry(429, "move_mount", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(430, "fsopen", kString, kFlags),
    MakeEntry(431, "fsconfig", kResource, kSubcommand, kPtr, kPtr, kInt),
    MakeEntry(432, "fsmount", kResource, kFlags, kFlags),
    MakeEntry(433, "fspick", kResource, kPath, kFlags),
    MakeEntry(434, "pidfd_open", kResource, kFlags),
    MakeEntry(435, "clone3", kPtr, kLen0),
    MakeEntry(436, "close_range", kInt, kInt, kInt),
    MakeEntry(437, "openat2", kInt, kPath, kInt, kInt),
    MakeEntry(438, "pidfd_getfd", kResource, kResource, kFlags),
    MakeEntry(439, "faccessat2", kResource, kPath, kInt, kInt),
    MakeEntry(440, "process_madvise", kResource, kPtr, kLen1, kInt, kFlags),
    MakeEntry(441, "epoll_pwait2", kResource, kArray, kLen1, kPtr, kPtr, kLen4),
    MakeEntry(442, "mount_setattr", kResource, kPath, kFlags, kPtr, kLen3),
    MakeEntry(443, "quotactl_fd", kResource, kSubcommand, kInt, kPtr),
    MakeEntry(444, "landlock_create_ruleset", kPtr, kLen0, kFlags),
    MakeEntry(445, "landlock_add_rule", kResource, kInt, kPtr, kFlags),
    MakeEntry(446, "landlock_restrict_self", kResource, kFlags),
    MakeEntry(447, "memfd_secret", kFlags),
    MakeEntry(448, "process_mrelease", kResource, kFlags),
    MakeEntry(449, "futex_waitv", kPtr, kLen0, kFlags, kPtr, kResource),
    MakeEntry(450, "set_mempolicy_home_node", kPtr, kLen0, kPtr, kFlags),
    MakeEntry(451, "cachestat", kResource, kPtr, kPtr, kFlags),
    MakeEntry(452, "fchmodat2", kResource, kPath, kInt, kFlags),
    MakeEntry(453, "map_shadow_stack", kPtr, kLen0, kFlags),
    MakeEntry(454, "futex_wake", kPtr, kInt, kInt, kFlags),
    MakeEntry(455, "futex_wait", kPtr, kInt, kInt, kFlags, kPtr, kInt),
    MakeEntry(456, "futex_requeue", kPtr, kFlags, kInt, kInt),
    MakeEntry(457, "statmount", kPtr, kPtr, kLen2, kFlags),
    MakeEntry(458, "listmount", kPtr, kPtr, kLen2, kFlags),
    MakeEntry(459, "lsm_get_self_attr", kInt, kPtr, kPtr, kFlags),
    MakeEntry(460, "lsm_set_self_attr", kInt, kPtr, kLen2, kFlags),
    MakeEntry(461, "lsm_list_modules", kPtr, kPtr, kFlags),
    MakeEntry(462, "mseal", kPtr, kLen0, kFlags),
    MakeEntry(463, "setxattrat", kResource, kPath, kFlags, kString, kPtr,
              kLen4),
    MakeEntry(464, "getxattrat", kResource, kPath, kFlags, kString, kPtr,
              kLen4),
    MakeEntry(465, "listxattrat", kResource, kPath, kFlags, kPtr, kLen3),
    MakeEntry(466, "removexattrat", kResource, kPath, kFlags, kString),
    MakeEntry(467, "open_tree_attr", kResource, kFlags, kPtr, kLen3),
    // clang-format on
};

static_assert(IsSorted(kSyscallDataX8664, SyscallTable::Entry::BySyscallNr),
              "Syscalls should be sorted");

constexpr std::array kSyscallDataX8632 = {
    // clang-format off
    MakeEntry(0, "restart_syscall"),
    MakeEntry(1, "exit", kInt),
    MakeEntry(2, "fork"),
    MakeEntry(3, "read", kResource, kArray, kLen1),
    MakeEntry(4, "write", kResource, kArray, kLen1),
    MakeEntry(5, "open", kPath, kFlags, kFlags),
    MakeEntry(6, "close", kResource),
    MakeEntry(7, "waitpid", kInt, kInt, kInt),
    MakeEntry(8, "creat", kPath, kFlags),
    MakeEntry(9, "link", kPath, kPath),
    MakeEntry(10, "unlink", kPath),
    MakeEntry(11, "execve", kPath, kArray, kArray),
    MakeEntry(12, "chdir", kPath),
    MakeEntry(13, "time", kPtr),
    MakeEntry(14, "mknod", kPath, kFlags, kInt),
    MakeEntry(15, "chmod", kPath, kFlags),
    MakeEntry(16, "lchown", kPath, kUid, kGid),
    MakeEntry(17, "break", UnknownArguments()),
    MakeEntry(18, "oldstat", UnknownArguments()),
    MakeEntry(19, "lseek", kResource, kInt, kFlags),
    MakeEntry(20, "getpid"),
    MakeEntry(21, "mount", kPtr, kPath, kString, kFlags, kString),
    MakeEntry(22, "umount", UnknownArguments()),
    MakeEntry(23, "setuid", kUid),
    MakeEntry(24, "getuid"),
    MakeEntry(25, "stime", UnknownArguments()),
    MakeEntry(26, "ptrace", kFlags, kPid),
    MakeEntry(27, "alarm", kInt),
    MakeEntry(28, "oldfstat", UnknownArguments()),
    MakeEntry(29, "pause"),
    MakeEntry(30, "utime", kPath, kPtr),
    MakeEntry(31, "stty", UnknownArguments()),
    MakeEntry(32, "gtty", UnknownArguments()),
    MakeEntry(33, "access", kPath, kInt),
    MakeEntry(34, "nice", UnknownArguments()),
    MakeEntry(35, "ftime", UnknownArguments()),
    MakeEntry(36, "sync"),
    MakeEntry(37, "kill", kPid, kSignal),
    MakeEntry(38, "rename", kPath, kPath),
    MakeEntry(39, "mkdir", kPath, kFlags),
    MakeEntry(40, "rmdir", kPath),
    MakeEntry(41, "dup", kResource),
    MakeEntry(42, "pipe", kPtr),
    MakeEntry(43, "times", kPtr),
    MakeEntry(44, "prof", UnknownArguments()),
    MakeEntry(45, "brk", kInt),
    MakeEntry(46, "setgid", kGid),
    MakeEntry(47, "getgid"),
    MakeEntry(48, "signal", UnknownArguments()),
    MakeEntry(49, "geteuid"),
    MakeEntry(50, "getegid"),
    MakeEntry(51, "acct", kPath),
    MakeEntry(52, "umount2", kPath, kFlags),
    MakeEntry(53, "lock", UnknownArguments()),
    MakeEntry(54, "ioctl", kResource, kSubcommand, kArray),
    MakeEntry(55, "fcntl", kResource, kSubcommand, kResource),
    MakeEntry(56, "mpx", UnknownArguments()),
    MakeEntry(57, "setpgid", kPid, kPid),
    MakeEntry(58, "ulimit", UnknownArguments()),
    MakeEntry(59, "oldolduname", UnknownArguments()),
    MakeEntry(60, "umask", kFlags),
    MakeEntry(61, "chroot", kPath),
    MakeEntry(62, "ustat", kInt, kPtr),
    MakeEntry(63, "dup2", kResource, kResource),
    MakeEntry(64, "getppid"),
    MakeEntry(65, "getpgrp", kPid),
    MakeEntry(66, "setsid"),
    MakeEntry(67, "sigaction", UnknownArguments()),
    MakeEntry(68, "sgetmask", UnknownArguments()),
    MakeEntry(69, "ssetmask", UnknownArguments()),
    MakeEntry(70, "setreuid", kUid, kUid),
    MakeEntry(71, "setregid", kGid, kGid),
    MakeEntry(72, "sigsuspend", UnknownArguments()),
    MakeEntry(73, "sigpending", UnknownArguments()),
    MakeEntry(74, "sethostname", kString, kLen0),
    MakeEntry(75, "setrlimit", kFlags, kPtr),
    MakeEntry(76, "getrlimit", kFlags, kPtr),
    MakeEntry(77, "getrusage", kFlags, kPtr),
    MakeEntry(78, "gettimeofday", kPtr, kPtr),
    MakeEntry(79, "settimeofday", kPtr, kPtr),
    MakeEntry(80, "getgroups", kLen1, kGidArray),
    MakeEntry(81, "setgroups", kLen1, kGidArray),
    MakeEntry(82, "select", kLen1, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(83, "symlink", kPath, kPath),
    MakeEntry(84, "oldlstat", UnknownArguments()),
    MakeEntry(85, "readlink", kPath, kArray, kLen1),
    MakeEntry(86, "uselib", kPath),
    MakeEntry(87, "swapon", kPath, kFlags),
    MakeEntry(88, "reboot", kInt, kInt, kSubcommand, kPtr),
    MakeEntry(89, "readdir", UnknownArguments()),
    MakeEntry(90, "mmap", kPtr, kLen0, kFlags, kFlags, kResource, kInt),
    MakeEntry(91, "munmap", kPtr, kLen0),
    MakeEntry(92, "truncate", kPath, kInt),
    MakeEntry(93, "ftruncate", kResource, kInt),
    MakeEntry(94, "fchmod", kResource, kFlags),
    MakeEntry(95, "fchown", kResource, kUid, kGid),
    MakeEntry(96, "getpriority", kFlags, kPid),
    MakeEntry(97, "setpriority", kFlags, kPid, kInt),
    MakeEntry(98, "profil", UnknownArguments()),
    MakeEntry(99, "statfs", kPath, kArray),
    MakeEntry(100, "fstatfs", kResource, kArray),
    MakeEntry(101, "ioperm", kInt, kInt, kInt),
    MakeEntry(102, "socketcall", UnknownArguments()),
    MakeEntry(103, "syslog", kSubcommand, kArray, kLen1),
    MakeEntry(104, "setitimer", kFlags, kPtr, kPtr),
    MakeEntry(105, "getitimer", kFlags, kPtr),
    MakeEntry(106, "stat", kPath, kPtr),
    MakeEntry(107, "lstat", kPath, kPtr),
    MakeEntry(108, "fstat", kResource, kPtr),
    MakeEntry(109, "olduname", UnknownArguments()),
    MakeEntry(110, "iopl", kInt),
    MakeEntry(111, "vhangup"),
    MakeEntry(112, "idle", UnknownArguments()),
    MakeEntry(113, "vm86old", UnknownArguments()),
    MakeEntry(114, "wait4", kPid, kPtr, kFlags, kPtr),
    MakeEntry(115, "swapoff", kPath),
    MakeEntry(116, "sysinfo", kArray),
    MakeEntry(117, "ipc", UnknownArguments()),
    MakeEntry(118, "fsync", kResource),
    MakeEntry(119, "sigreturn", UnknownArguments()),
    MakeEntry(120, "clone", kFlags, kArray, kPtr, kPtr, kArray),
    MakeEntry(121, "setdomainname", kString, kLen0),
    MakeEntry(122, "uname", kArray),
    MakeEntry(123, "modify_ldt", kInt, kPtr, kLen1),
    MakeEntry(124, "adjtimex", kArray),
    MakeEntry(125, "mprotect", kPtr, kLen0, kFlags),
    MakeEntry(126, "sigprocmask", UnknownArguments()),
    MakeEntry(127, "create_module", kString, kInt),
    MakeEntry(128, "init_module", kString, kLen0, kString),
    MakeEntry(129, "delete_module", kString, kFlags),
    MakeEntry(130, "get_kernel_syms", kInt),
    MakeEntry(131, "quotactl", kSubcommand, kPath, kInt, kGen),
    MakeEntry(132, "getpgid", kPid),
    MakeEntry(133, "fchdir", kResource),
    MakeEntry(134, "bdflush", UnknownArguments()),
    MakeEntry(135, "sysfs", kInt, kString),
    MakeEntry(136, "personality", kFlags),
    MakeEntry(137, "afs_syscall", UnknownArguments()),
    MakeEntry(138, "setfsuid", kUid),
    MakeEntry(139, "setfsgid", kGid),
    MakeEntry(140, "_llseek", UnknownArguments()),
    MakeEntry(141, "getdents", kResource, kArray, kLen1),
    MakeEntry(142, "_newselect", UnknownArguments()),
    MakeEntry(143, "flock", kResource, kFlags),
    MakeEntry(144, "msync", kPtr, kLen0, kFlags),
    MakeEntry(145, "readv", kResource, kArray, kLen1),
    MakeEntry(146, "writev", kResource, kArray, kLen1),
    MakeEntry(147, "getsid", kPid),
    MakeEntry(148, "fdatasync", kResource),
    MakeEntry(149, "_sysctl", kPtr),
    MakeEntry(150, "mlock", kPtr, kLen0),
    MakeEntry(151, "munlock", kPtr, kLen0),
    MakeEntry(152, "mlockall", kFlags),
    MakeEntry(153, "munlockall"),
    MakeEntry(154, "sched_setparam", kPid, kPtr),
    MakeEntry(155, "sched_getparam", kPid, kPtr),
    MakeEntry(156, "sched_setscheduler", kPid, kFlags, kPtr),
    MakeEntry(157, "sched_getscheduler", kPid),
    MakeEntry(158, "sched_yield"),
    MakeEntry(159, "sched_get_priority_max", kInt),
    MakeEntry(160, "sched_get_priority_min", kInt),
    MakeEntry(161, "sched_rr_get_interval", kPid, kPtr),
    MakeEntry(162, "nanosleep", kPtr, kPtr),
    MakeEntry(163, "mremap", kPtr, kLen0, kLen4, kFlags, kPtr),
    MakeEntry(164, "setresuid", kUid, kUid, kUid),
    MakeEntry(165, "getresuid", kPtr, kPtr, kPtr),
    MakeEntry(166, "vm86", UnknownArguments()),
    MakeEntry(167, "query_module", kString, kInt, kGen, kInt, kGen),
    MakeEntry(168, "poll", kPollFdArray, kLen0, kInt),
    MakeEntry(169, "nfsservctl", kSubcommand, kPtr, kPtr),
    MakeEntry(170, "setresgid", kGid, kGid, kGid),
    MakeEntry(171, "getresgid", kPtr, kPtr, kPtr),
    MakeEntry(172, "prctl", kSubcommand, kSubcommand, kInt, kInt, kInt),
    MakeEntry(173, "rt_sigreturn"),
    MakeEntry(174, "rt_sigaction", kSignal, kPtr, kPtr, kLen4, kPtr),
    MakeEntry(175, "rt_sigprocmask", kFlags, kPtr, kPtr, kLen1),
    MakeEntry(176, "rt_sigpending", kPtr, kLen0),
    MakeEntry(177, "rt_sigtimedwait", kPtr, kPtr, kPtr, kLen0),
    MakeEntry(178, "rt_sigqueueinfo", kPid, kSignal, kPtr),
    MakeEntry(179, "rt_sigsuspend", kPtr, kLen0),
    MakeEntry(180, "pread64", kResource, kArray, kLen1, kInt),
    MakeEntry(181, "pwrite64", kResource, kArray, kLen1, kInt),
    MakeEntry(182, "chown", kPath, kUid, kGid),
    MakeEntry(183, "getcwd", kArray, kLen0),
    MakeEntry(184, "capget", kPtr, kPtr),
    MakeEntry(185, "capset", kPtr, kPtr),
    MakeEntry(186, "sigaltstack", kPtr, kPtr),
    MakeEntry(187, "sendfile", kResource, kResource, kPtr, kInt),
    MakeEntry(188, "getpmsg", UnknownArguments()),
    MakeEntry(189, "putpmsg", UnknownArguments()),
    MakeEntry(190, "vfork"),
    MakeEntry(191, "ugetrlimit", UnknownArguments()),
    MakeEntry(192, "mmap2", UnknownArguments()),
    MakeEntry(193, "truncate64", kPath, kInt),
    MakeEntry(194, "ftruncate64", kInt, kInt),
    MakeEntry(195, "stat64", kPath, kPtr),
    MakeEntry(196, "lstat64", kPath, kPtr),
    MakeEntry(197, "fstat64", kResource, kPtr),
    MakeEntry(198, "lchown32", kPath, kInt, kInt),
    MakeEntry(199, "getuid32", UnknownArguments()),
    MakeEntry(200, "getgid32", UnknownArguments()),
    MakeEntry(201, "geteuid32", UnknownArguments()),
    MakeEntry(202, "getegid32", UnknownArguments()),
    MakeEntry(203, "setreuid32", UnknownArguments()),
    MakeEntry(204, "setregid32", UnknownArguments()),
    MakeEntry(205, "getgroups32", UnknownArguments()),
    MakeEntry(206, "setgroups32", UnknownArguments()),
    MakeEntry(207, "fchown32", UnknownArguments()),
    MakeEntry(208, "setresuid32", UnknownArguments()),
    MakeEntry(209, "getresuid32", UnknownArguments()),
    MakeEntry(210, "setresgid32", UnknownArguments()),
    MakeEntry(211, "getresgid32", UnknownArguments()),
    MakeEntry(212, "chown32", UnknownArguments()),
    MakeEntry(213, "setuid32", UnknownArguments()),
    MakeEntry(214, "setgid32", UnknownArguments()),
    MakeEntry(215, "setfsuid32", UnknownArguments()),
    MakeEntry(216, "setfsgid32", UnknownArguments()),
    MakeEntry(217, "pivot_root", kPath, kPath),
    MakeEntry(218, "mincore", kPtr, kLen0, kArray),
    MakeEntry(219, "madvise", kPtr, kLen0, kFlags),
    MakeEntry(220, "getdents64", kResource, kArray, kLen1),
    MakeEntry(221, "fcntl64", UnknownArguments()),
    MakeEntry(222, "unused1-222", UnknownArguments()),
    MakeEntry(223, "unused2-223", UnknownArguments()),
    MakeEntry(224, "gettid"),
    MakeEntry(225, "readahead", kResource, kInt, kInt),
    MakeEntry(226, "setxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(227, "lsetxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(228, "fsetxattr", kResource, kPtr, kString, kLen2, kFlags),
    MakeEntry(229, "getxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(230, "lgetxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(231, "fgetxattr", kResource, kPtr, kArray, kLen2),
    MakeEntry(232, "listxattr", kPath, kArray, kLen1),
    MakeEntry(233, "llistxattr", kPath, kArray, kLen1),
    MakeEntry(234, "flistxattr", kResource, kArray, kLen1),
    MakeEntry(235, "removexattr", kPath, kPtr),
    MakeEntry(236, "lremovexattr", kPath, kPtr),
    MakeEntry(237, "fremovexattr", kResource, kPtr),
    MakeEntry(238, "tkill", kPid, kSignal),
    MakeEntry(239, "sendfile64", kResource, kResource, kPtr, kInt),
    MakeEntry(240, "futex", kPtr, kFlags, kInt, kPtr, kPtr, kInt),
    MakeEntry(241, "sched_setaffinity", kPid, kLen2, kPtr),
    MakeEntry(242, "sched_getaffinity", kPid, kLen2, kPtr),
    MakeEntry(243, "set_thread_area", kPtr),
    MakeEntry(244, "get_thread_area", kPtr),
    MakeEntry(245, "io_setup", kInt, kPtr),
    MakeEntry(246, "io_destroy", kStruct),
    MakeEntry(247, "io_getevents", kStruct, kInt, kLen3, kArray, kPtr),
    MakeEntry(248, "io_submit", kStruct, kLen2, kArray),
    MakeEntry(249, "io_cancel", kStruct, kPtr, kPtr),
    MakeEntry(250, "fadvise64", kResource, kInt, kInt, kFlags),
    MakeEntry(251, "251-old_sys_set_zone_reclaim", UnknownArguments()),
    MakeEntry(252, "exit_group", kInt),
    MakeEntry(253, "lookup_dcookie", kInt, kArray, kLen1),
    MakeEntry(254, "epoll_create", kInt),
    MakeEntry(255, "epoll_ctl", kResource, kInt, kResource, kPtr),
    MakeEntry(256, "epoll_wait", kResource, kArray, kLen1, kInt),
    MakeEntry(257, "remap_file_pages", kPtr, kLen0, kFlags, kInt, kFlags),
    MakeEntry(258, "set_tid_address", kPtr),
    MakeEntry(259, "timer_create", kFlags, kPtr, kPtr),
    MakeEntry(260, "timer_settime", kStruct, kFlags, kPtr, kPtr),
    MakeEntry(261, "timer_gettime", kStruct, kPtr),
    MakeEntry(262, "timer_getoverrun", kStruct),
    MakeEntry(263, "timer_delete", kStruct),
    MakeEntry(264, "clock_settime", kFlags, kPtr),
    MakeEntry(265, "clock_gettime", kFlags, kPtr),
    MakeEntry(266, "clock_getres", kFlags, kPtr),
    MakeEntry(267, "clock_nanosleep", kFlags, kFlags, kPtr, kPtr),
    MakeEntry(268, "statfs64", UnknownArguments()),
    MakeEntry(269, "fstatfs64", UnknownArguments()),
    MakeEntry(270, "tgkill", kPid, kPid, kSignal),
    MakeEntry(271, "utimes", kPath, kPtr),
    MakeEntry(272, "fadvise64_64", UnknownArguments()),
    MakeEntry(273, "vserver", UnknownArguments()),
    MakeEntry(274, "mbind", kPtr, kLen0, kFlags, kPtr, kInt, kFlags),
    MakeEntry(275, "get_mempolicy", kPtr, kPtr, kInt, kPtr, kFlags),
    MakeEntry(276, "set_mempolicy", kFlags, kPtr, kInt),
    MakeEntry(277, "mq_open", kString, kFlags, kFlags, kPtr),
    MakeEntry(278, "mq_unlink", kString),
    MakeEntry(279, "mq_timedsend", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(280, "mq_timedreceive", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(281, "mq_notify", kResource, kPtr),
    MakeEntry(282, "mq_getsetattr", kResource, kPtr, kPtr),
    MakeEntry(283, "kexec_load", kInt, kLen2, kArray, kFlags),
    MakeEntry(284, "waitid", kFlags, kPid, kPtr, kFlags, kPtr),
    MakeEntry(285, "285-old_sys_setaltroot", UnknownArguments()),
    MakeEntry(286, "add_key", kString, kPtr, kArray, kLen2, kStruct),
    MakeEntry(287, "request_key", kString, kPtr, kString, kStruct),
    MakeEntry(288, "keyctl", kInt, kInt, kInt, kInt, kInt),
    MakeEntry(289, "ioprio_set", kFlags, kPid, kFlags),
    MakeEntry(290, "ioprio_get", kFlags, kUid),
    MakeEntry(291, "inotify_init"),
    MakeEntry(292, "inotify_add_watch", kResource, kPath, kFlags),
    MakeEntry(293, "inotify_rm_watch", kResource, kResource),
    MakeEntry(294, "migrate_pages", kPid, kInt, kPtr, kPtr),
    MakeEntry(295, "openat", kResource, kPath, kFlags, kFlags),
    MakeEntry(296, "mkdirat", kResource, kPath, kFlags),
    MakeEntry(297, "mknodat", kResource, kPath, kFlags, kInt),
    MakeEntry(298, "fchownat", kResource, kPath, kUid, kGid, kFlags),
    MakeEntry(299, "futimesat", kResource, kPath, kPtr),
    MakeEntry(300, "fstatat64", kInt, kPath, kPtr, kFlags),
    MakeEntry(301, "unlinkat", kResource, kPath, kFlags),
    MakeEntry(302, "renameat", kResource, kPath, kResource, kPath),
    MakeEntry(303, "linkat", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(304, "symlinkat", kPath, kResource, kPath),
    MakeEntry(305, "readlinkat", kResource, kPath, kArray, kLen2),
    MakeEntry(306, "fchmodat", kResource, kPath, kFlags),
    MakeEntry(307, "faccessat", kResource, kPath, kFlags),
    MakeEntry(308, "pselect6", kLen1, kPtr, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(309, "ppoll", kPollFdArray, kLen0, kPtr, kPtr, kLen3),
    MakeEntry(310, "unshare", kFlags),
    MakeEntry(311, "set_robust_list", kPtr, kLen0),
    MakeEntry(312, "get_robust_list", kPid, kPtr, kPtr),
    MakeEntry(313, "splice", kResource, kPtr, kResource, kPtr, kInt, kFlags),
    MakeEntry(314, "sync_file_range", kResource, kInt, kInt, kFlags),
    MakeEntry(315, "tee", kResource, kResource, kInt, kFlags),
    MakeEntry(316, "vmsplice", kResource, kArray, kLen1, kFlags),
    MakeEntry(317, "move_pages", kPid, kLen2, kArray, kArray, kArray, kFlags),
    MakeEntry(318, "getcpu", kPtr, kPtr),
    MakeEntry(319, "epoll_pwait", kResource, kArray, kLen1, kInt, kPtr, kLen4),
    MakeEntry(320, "utimensat", kResource, kPath, kPtr, kFlags),
    MakeEntry(321, "signalfd", kResource, kPtr, kLen1),
    MakeEntry(322, "timerfd_create", kFlags, kFlags),
    MakeEntry(323, "eventfd", kInt),
    MakeEntry(324, "fallocate", kResource, kFlags, kInt, kInt),
    MakeEntry(325, "timerfd_settime", kResource, kFlags, kPtr, kPtr),
    MakeEntry(326, "timerfd_gettime", kResource, kPtr),
    MakeEntry(327, "signalfd4", kResource, kPtr, kLen1, kFlags),
    MakeEntry(328, "eventfd2", kInt, kFlags),
    MakeEntry(329, "epoll_create1", kFlags),
    MakeEntry(330, "dup3", kResource, kResource, kFlags),
    MakeEntry(331, "pipe2", kPtr, kFlags),
    MakeEntry(332, "inotify_init1", kFlags),
    MakeEntry(333, "preadv", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(334, "pwritev", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(335, "rt_tgsigqueueinfo", kPid, kPid, kSignal, kPtr),
    MakeEntry(336, "perf_event_open", kPtr, kPid, kInt, kResource, kFlags),
    MakeEntry(337, "recvmmsg", kResource, kArray, kLen1, kFlags, kPtr),
    MakeEntry(338, "fanotify_init", kFlags, kFlags),
    MakeEntry(339, "fanotify_mark", kResource, kFlags, kFlags, kResource,
              kPath),
    MakeEntry(340, "prlimit64", kPid, kFlags, kPtr, kPtr),
    MakeEntry(341, "name_to_handle_at", kResource, kPath, kPtr, kPtr, kFlags),
    MakeEntry(342, "open_by_handle_at", kResource, kPtr, kFlags),
    MakeEntry(343, "clock_adjtime", kFlags, kPtr),
    MakeEntry(344, "syncfs", kResource),
    MakeEntry(345, "sendmmsg", kResource, kArray, kLen1, kFlags),
    MakeEntry(346, "setns", kResource, kFlags),
    MakeEntry(347, "process_vm_readv", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(348, "process_vm_writev", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(349, "kcmp", kPid, kPid, kFlags, kResource, kResource),
    MakeEntry(350, "finit_module", kResource, kString, kFlags),
    MakeEntry(351, "sched_setattr", kPid, kPtr, kInt),
    MakeEntry(352, "sched_getattr", kPid, kPtr, kLen1, kInt),
    MakeEntry(353, "renameat2", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(354, "seccomp", kInt, kFlags, kPtr),
    MakeEntry(355, "getrandom", kArray, kLen0, kFlags),
    MakeEntry(356, "memfd_create", kString, kFlags),
    MakeEntry(357, "bpf", kSubcommand, kPtr, kLen1),
    MakeEntry(435, "clone3", kPtr, kLen0),
    MakeEntry(436, "close_range", kResource, kResource, kFlags),
    MakeEntry(437, "openat2", kResource, kPath, kPtr, kLen2),
    MakeEntry(438, "pidfd_getfd", kResource, kResource, kInt),
    MakeEntry(439, "faccessat2", kResource, kPath, kFlags, kFlags),
    MakeEntry(440, "process_madvise", kResource, kArray, kLen1, kFlags, kInt),
    MakeEntry(441, "epoll_pwait2", kResource, kArray, kLen1, kPtr, kPtr, kLen4),
    MakeEntry(442, "mount_setattr", kResource, kPath, kFlags, kPtr, kLen3),
    MakeEntry(443, "quotactl_fd", UnknownArguments()),
    MakeEntry(444, "landlock_create_ruleset", kPtr, kLen0, kInt),
    MakeEntry(445, "landlock_add_rule", kResource, kInt, kPtr, kInt),
    MakeEntry(446, "landlock_restrict_self", kResource, kInt),
    MakeEntry(447, "memfd_secret", kFlags),
    MakeEntry(448, "process_mrelease", kResource, kInt),
    MakeEntry(449, "futex_waitv", kArray, kLen0, kInt, kPtr, kFlags),
    MakeEntry(450, "set_mempolicy_home_node", kPtr, kLen0, kInt, kInt),
    MakeEntry(451, "cachestat", kResource, kPtr, kPtr, kInt),
    MakeEntry(452, "fchmodat2", kInt, kPath, kInt, kInt),
    MakeEntry(453, "map_shadow_stack", kPtr, kLen0, kFlags),
    MakeEntry(454, "futex_wake", UnknownArguments()),
    MakeEntry(455, "futex_wait", UnknownArguments()),
    MakeEntry(456, "futex_requeue", UnknownArguments()),
    MakeEntry(457, "statmount", UnknownArguments()),
    MakeEntry(458, "listmount", UnknownArguments()),
    MakeEntry(459, "lsm_get_self_attr", UnknownArguments()),
    MakeEntry(460, "lsm_set_self_attr", UnknownArguments()),
    MakeEntry(461, "lsm_list_modules", UnknownArguments()),
    // clang-format on
};

static_assert(IsSorted(kSyscallDataX8632, SyscallTable::Entry::BySyscallNr),
              "Syscalls should be sorted");

// http://lxr.free-electrons.com/source/arch/powerpc/include/uapi/asm/unistd.h
// Note: PPC64 syscalls can have up to 7 register arguments, but nobody is
// using the 7th argument - probably for x64 compatibility reasons.
constexpr std::array kSyscallDataPPC64LE = {
    // clang-format off
    MakeEntry(0, "restart_syscall"),
    MakeEntry(1, "exit", kInt),
    MakeEntry(2, "fork"),
    MakeEntry(3, "read", kResource, kArray, kLen1),
    MakeEntry(4, "write", kResource, kArray, kLen1),
    MakeEntry(5, "open", kPath, kFlags, kFlags),
    MakeEntry(6, "close", kResource),
    MakeEntry(7, "waitpid", kInt, kInt, kInt),
    MakeEntry(8, "creat", kPath, kFlags),
    MakeEntry(9, "link", kPath, kPath),
    MakeEntry(10, "unlink", kPath),
    MakeEntry(11, "execve", kPath, kArray, kArray),
    MakeEntry(12, "chdir", kPath),
    MakeEntry(13, "time", kPtr),
    MakeEntry(14, "mknod", kPath, kFlags, kInt),
    MakeEntry(15, "chmod", kPath, kFlags),
    MakeEntry(16, "lchown", kPath, kUid, kGid),
    MakeEntry(17, "break", UnknownArguments()),
    MakeEntry(18, "oldstat", UnknownArguments()),
    MakeEntry(19, "lseek", kResource, kInt, kFlags),
    MakeEntry(20, "getpid"),
    MakeEntry(21, "mount", kPtr, kPath, kString, kFlags, kString),
    MakeEntry(22, "umount", UnknownArguments()),
    MakeEntry(23, "setuid", kUid),
    MakeEntry(24, "getuid"),
    MakeEntry(25, "stime", UnknownArguments()),
    MakeEntry(26, "ptrace", kFlags, kPid),
    MakeEntry(27, "alarm", kInt),
    MakeEntry(28, "oldfstat", UnknownArguments()),
    MakeEntry(29, "pause"),
    MakeEntry(30, "utime", kPath, kPtr),
    MakeEntry(31, "stty", UnknownArguments()),
    MakeEntry(32, "gtty", UnknownArguments()),
    MakeEntry(33, "access", kPath, kFlags),
    MakeEntry(34, "nice", UnknownArguments()),
    MakeEntry(35, "ftime", UnknownArguments()),
    MakeEntry(36, "sync"),
    MakeEntry(37, "kill", kPid, kSignal),
    MakeEntry(38, "rename", kPath, kPath),
    MakeEntry(39, "mkdir", kPath, kFlags),
    MakeEntry(40, "rmdir", kPath),
    MakeEntry(41, "dup", kResource),
    MakeEntry(42, "pipe", kPtr),
    MakeEntry(43, "times", kPtr),
    MakeEntry(44, "prof", UnknownArguments()),
    MakeEntry(45, "brk", kInt),
    MakeEntry(46, "setgid", kGid),
    MakeEntry(47, "getgid"),
    MakeEntry(48, "signal", UnknownArguments()),
    MakeEntry(49, "geteuid"),
    MakeEntry(50, "getegid"),
    MakeEntry(51, "acct", kPath),
    MakeEntry(52, "umount2", kPath, kFlags),
    MakeEntry(53, "lock", UnknownArguments()),
    MakeEntry(54, "ioctl", kResource, kSubcommand, kArray),
    MakeEntry(55, "fcntl", kResource, kSubcommand, kResource),
    MakeEntry(56, "mpx", UnknownArguments()),
    MakeEntry(57, "setpgid", kPid, kPid),
    MakeEntry(58, "ulimit", UnknownArguments()),
    MakeEntry(59, "oldolduname", UnknownArguments()),
    MakeEntry(60, "umask", kFlags),
    MakeEntry(61, "chroot", kPath),
    MakeEntry(62, "ustat", kInt, kPtr),
    MakeEntry(63, "dup2", kResource, kResource),
    MakeEntry(64, "getppid"),
    MakeEntry(65, "getpgrp", kPid),
    MakeEntry(66, "setsid"),
    MakeEntry(67, "sigaction", UnknownArguments()),
    MakeEntry(68, "sgetmask", UnknownArguments()),
    MakeEntry(69, "ssetmask", UnknownArguments()),
    MakeEntry(70, "setreuid", kUid, kUid),
    MakeEntry(71, "setregid", kGid, kGid),
    MakeEntry(72, "sigsuspend", UnknownArguments()),
    MakeEntry(73, "sigpending", UnknownArguments()),
    MakeEntry(74, "sethostname", kString, kLen0),
    MakeEntry(75, "setrlimit", kFlags, kPtr),
    MakeEntry(76, "getrlimit", kFlags, kPtr),
    MakeEntry(77, "getrusage", kFlags, kPtr),
    MakeEntry(78, "gettimeofday", kPtr, kPtr),
    MakeEntry(79, "settimeofday", kPtr, kPtr),
    MakeEntry(80, "getgroups", kLen1, kGidArray),
    MakeEntry(81, "setgroups", kLen1, kGidArray),
    MakeEntry(82, "select", kLen1, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(83, "symlink", kPath, kPath),
    MakeEntry(84, "oldlstat", UnknownArguments()),
    MakeEntry(85, "readlink", kPath, kArray, kLen1),
    MakeEntry(86, "uselib", kPath),
    MakeEntry(87, "swapon", kPath, kFlags),
    MakeEntry(88, "reboot", kInt, kInt, kSubcommand, kPtr),
    MakeEntry(89, "readdir", UnknownArguments()),
    MakeEntry(90, "mmap", kPtr, kLen0, kFlags, kFlags, kResource, kInt),
    MakeEntry(91, "munmap", kPtr, kLen0),
    MakeEntry(92, "truncate", kPath, kInt),
    MakeEntry(93, "ftruncate", kResource, kInt),
    MakeEntry(94, "fchmod", kResource, kFlags),
    MakeEntry(95, "fchown", kResource, kUid, kGid),
    MakeEntry(96, "getpriority", kFlags, kPid),
    MakeEntry(97, "setpriority", kFlags, kPid, kInt),
    MakeEntry(98, "profil", UnknownArguments()),
    MakeEntry(99, "statfs", kPath, kArray),
    MakeEntry(100, "fstatfs", kResource, kArray),
    MakeEntry(101, "ioperm", kInt, kInt, kInt),
    MakeEntry(102, "socketcall", UnknownArguments()),
    MakeEntry(103, "syslog", kSubcommand, kArray, kLen1),
    MakeEntry(104, "setitimer", kFlags, kPtr, kPtr),
    MakeEntry(105, "getitimer", kFlags, kPtr),
    MakeEntry(106, "stat", kPath, kPtr),
    MakeEntry(107, "lstat", kPath, kPtr),
    MakeEntry(108, "fstat", kResource, kPtr),
    MakeEntry(109, "olduname", UnknownArguments()),
    MakeEntry(110, "iopl", kInt),
    MakeEntry(111, "vhangup"),
    MakeEntry(112, "idle", UnknownArguments()),
    MakeEntry(113, "vm86", UnknownArguments()),
    MakeEntry(114, "wait4", kPid, kPtr, kFlags, kPtr),
    MakeEntry(115, "swapoff", kPath),
    MakeEntry(116, "sysinfo", kArray),
    MakeEntry(117, "ipc", UnknownArguments()),
    MakeEntry(118, "fsync", kResource),
    MakeEntry(119, "sigreturn", UnknownArguments()),
    MakeEntry(120, "clone", kFlags, kArray, kPtr, kPtr, kArray),
    MakeEntry(121, "setdomainname", kString, kLen0),
    MakeEntry(122, "uname", kArray),
    MakeEntry(123, "modify_ldt", kInt, kPtr, kLen1),
    MakeEntry(124, "adjtimex", kArray),
    MakeEntry(125, "mprotect", kPtr, kLen0, kFlags),
    MakeEntry(126, "sigprocmask", UnknownArguments()),
    MakeEntry(127, "create_module", kString, kInt),
    MakeEntry(128, "init_module", kString, kLen0, kString),
    MakeEntry(129, "delete_module", kString, kFlags),
    MakeEntry(130, "get_kernel_syms", kInt),
    MakeEntry(131, "quotactl", kSubcommand, kPath, kInt, kGen),
    MakeEntry(132, "getpgid", kPid),
    MakeEntry(133, "fchdir", kResource),
    MakeEntry(134, "bdflush", UnknownArguments()),
    MakeEntry(135, "sysfs", kInt, kString),
    MakeEntry(136, "personality", kFlags),
    MakeEntry(137, "afs_syscall", UnknownArguments()),
    MakeEntry(138, "setfsuid", kUid),
    MakeEntry(139, "setfsgid", kGid),
    MakeEntry(140, "_llseek", UnknownArguments()),
    MakeEntry(141, "getdents", kResource, kArray, kLen1),
    MakeEntry(142, "_newselect", UnknownArguments()),
    MakeEntry(143, "flock", kResource, kFlags),
    MakeEntry(144, "msync", kPtr, kLen0, kFlags),
    MakeEntry(145, "readv", kResource, kArray, kLen1),
    MakeEntry(146, "writev", kResource, kArray, kLen1),
    MakeEntry(147, "getsid", kPid),
    MakeEntry(148, "fdatasync", kResource),
    MakeEntry(149, "_sysctl", kPtr),
    MakeEntry(150, "mlock", kPtr, kLen0),
    MakeEntry(151, "munlock", kPtr, kLen0),
    MakeEntry(152, "mlockall", kFlags),
    MakeEntry(153, "munlockall"),
    MakeEntry(154, "sched_setparam", kPid, kPtr),
    MakeEntry(155, "sched_getparam", kPid, kPtr),
    MakeEntry(156, "sched_setscheduler", kPid, kFlags, kPtr),
    MakeEntry(157, "sched_getscheduler", kPid),
    MakeEntry(158, "sched_yield"),
    MakeEntry(159, "sched_get_priority_max", kInt),
    MakeEntry(160, "sched_get_priority_min", kInt),
    MakeEntry(161, "sched_rr_get_interval", kPid, kPtr),
    MakeEntry(162, "nanosleep", kPtr, kPtr),
    MakeEntry(163, "mremap", kPtr, kLen0, kLen4, kFlags, kPtr),
    MakeEntry(164, "setresuid", kUid, kUid, kUid),
    MakeEntry(165, "getresuid", kPtr, kPtr, kPtr),
    MakeEntry(166, "query_module", kString, kInt, kGen, kInt, kGen),
    MakeEntry(167, "poll", kPollFdArray, kLen0, kInt),
    MakeEntry(168, "nfsservctl", kSubcommand, kPtr, kPtr),
    MakeEntry(169, "setresgid", kGid, kGid, kGid),
    MakeEntry(170, "getresgid", kPtr, kPtr, kPtr),
    MakeEntry(171, "prctl", kSubcommand, kSubcommand, kInt, kInt, kInt),
    MakeEntry(172, "rt_sigreturn"),
    MakeEntry(173, "rt_sigaction", kSignal, kPtr, kPtr, kLen4, kPtr),
    MakeEntry(174, "rt_sigprocmask", kFlags, kPtr, kPtr, kLen1),
    MakeEntry(175, "rt_sigpending", kPtr, kLen0),
    MakeEntry(176, "rt_sigtimedwait", kPtr, kPtr, kPtr, kLen0),
    MakeEntry(177, "rt_sigqueueinfo", kPid, kSignal, kPtr),
    MakeEntry(178, "rt_sigsuspend", kPtr, kLen0),
    MakeEntry(179, "pread64", kResource, kArray, kLen1, kInt),
    MakeEntry(180, "pwrite64", kResource, kArray, kLen1, kInt),
    MakeEntry(181, "chown", kPath, kUid, kGid),
    MakeEntry(182, "getcwd", kArray, kLen0),
    MakeEntry(183, "capget", kPtr, kPtr),
    MakeEntry(184, "capset", kPtr, kPtr),
    MakeEntry(185, "sigaltstack", kPtr, kPtr),
    MakeEntry(186, "sendfile", kResource, kResource, kPtr, kInt),
    MakeEntry(187, "getpmsg", UnknownArguments()),
    MakeEntry(188, "putpmsg", UnknownArguments()),
    MakeEntry(189, "vfork"),
    MakeEntry(190, "ugetrlimit", UnknownArguments()),
    MakeEntry(191, "readahead", kResource, kInt, kInt),
    MakeEntry(192, "mmap2", UnknownArguments()),
    MakeEntry(193, "truncate64", UnknownArguments()),
    MakeEntry(194, "ftruncate64", UnknownArguments()),
    MakeEntry(195, "stat64", kPath, kPtr),
    MakeEntry(196, "lstat64", kPath, kPtr),
    MakeEntry(197, "fstat64", kResource, kPtr),
    MakeEntry(198, "pciconfig_read", UnknownArguments()),
    MakeEntry(199, "pciconfig_write", UnknownArguments()),
    MakeEntry(200, "pciconfig_iobase", UnknownArguments()),
    MakeEntry(201, "multiplexer", UnknownArguments()),
    MakeEntry(202, "getdents64", kResource, kArray, kLen1),
    MakeEntry(203, "pivot_root", kPath, kPath),
    MakeEntry(204, "fcntl64", UnknownArguments()),
    MakeEntry(205, "madvise", kPtr, kLen0, kFlags),
    MakeEntry(206, "mincore", kPtr, kLen0, kArray),
    MakeEntry(207, "gettid"),
    MakeEntry(208, "tkill", kPid, kSignal),
    MakeEntry(209, "setxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(210, "lsetxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(211, "fsetxattr", kResource, kPtr, kString, kLen2, kFlags),
    MakeEntry(212, "getxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(213, "lgetxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(214, "fgetxattr", kResource, kPtr, kArray, kLen2),
    MakeEntry(215, "listxattr", kPath, kArray, kLen1),
    MakeEntry(216, "llistxattr", kPath, kArray, kLen1),
    MakeEntry(217, "flistxattr", kResource, kArray, kLen1),
    MakeEntry(218, "removexattr", kPath, kPtr),
    MakeEntry(219, "lremovexattr", kPath, kPtr),
    MakeEntry(220, "fremovexattr", kResource, kPtr),
    MakeEntry(221, "futex", kPtr, kFlags, kInt, kPtr, kPtr, kInt),
    MakeEntry(222, "sched_setaffinity", kPid, kLen2, kPtr),
    MakeEntry(223, "sched_getaffinity", kPid, kLen2, kPtr),
    MakeEntry(225, "tuxcall", UnknownArguments()),
    MakeEntry(226, "sendfile64", kResource, kResource, kPtr, kInt),
    MakeEntry(227, "io_setup", kInt, kPtr),
    MakeEntry(228, "io_destroy", kStruct),
    MakeEntry(229, "io_getevents", kStruct, kInt, kLen3, kArray, kPtr),
    MakeEntry(230, "io_submit", kStruct, kLen2, kArray),
    MakeEntry(231, "io_cancel", kStruct, kPtr, kPtr),
    MakeEntry(232, "set_tid_address", kPtr),
    MakeEntry(233, "fadvise64", kResource, kInt, kInt, kFlags),
    MakeEntry(234, "exit_group", kInt),
    MakeEntry(235, "lookup_dcookie", kInt, kArray, kLen1),
    MakeEntry(236, "epoll_create", kInt),
    MakeEntry(237, "epoll_ctl", kResource, kInt, kResource, kPtr),
    MakeEntry(238, "epoll_wait", kResource, kArray, kLen1, kInt),
    MakeEntry(239, "remap_file_pages", kPtr, kLen0, kFlags, kInt, kFlags),
    MakeEntry(240, "timer_create", kFlags, kPtr, kPtr),
    MakeEntry(241, "timer_settime", kStruct, kFlags, kPtr, kPtr),
    MakeEntry(242, "timer_gettime", kStruct, kPtr),
    MakeEntry(243, "timer_getoverrun", kStruct),
    MakeEntry(244, "timer_delete", kStruct),
    MakeEntry(245, "clock_settime", kFlags, kPtr),
    MakeEntry(246, "clock_gettime", kFlags, kPtr),
    MakeEntry(247, "clock_getres", kFlags, kPtr),
    MakeEntry(248, "clock_nanosleep", kFlags, kFlags, kPtr, kPtr),
    MakeEntry(249, "swapcontext", UnknownArguments()),
    MakeEntry(250, "tgkill", kPid, kPid, kSignal),
    MakeEntry(251, "utimes", kPath, kPtr),
    MakeEntry(252, "statfs64", UnknownArguments()),
    MakeEntry(253, "fstatfs64", UnknownArguments()),
    MakeEntry(254, "fadvise64_64", UnknownArguments()),
    MakeEntry(255, "rtas", UnknownArguments()),
    MakeEntry(256, "sys_debug_setcontext", kInt, kInt, kInt, kInt, kInt, kInt),
    MakeEntry(258, "migrate_pages", kPid, kInt, kPtr, kPtr),
    MakeEntry(259, "mbind", kPtr, kLen0, kFlags, kPtr, kInt, kFlags),
    MakeEntry(260, "get_mempolicy", kPtr, kPtr, kInt, kPtr, kFlags),
    MakeEntry(261, "set_mempolicy", kFlags, kPtr, kInt),
    MakeEntry(262, "mq_open", kString, kFlags, kFlags, kPtr),
    MakeEntry(263, "mq_unlink", kString),
    MakeEntry(264, "mq_timedsend", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(265, "mq_timedreceive", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(266, "mq_notify", kResource, kPtr),
    MakeEntry(267, "mq_getsetattr", kResource, kPtr, kPtr),
    MakeEntry(268, "kexec_load", kInt, kLen2, kArray, kFlags),
    MakeEntry(269, "add_key", kString, kPtr, kArray, kLen2, kStruct),
    MakeEntry(270, "request_key", kString, kPtr, kString, kStruct),
    MakeEntry(271, "keyctl", kInt, kInt, kInt, kInt, kInt),
    MakeEntry(272, "waitid", kFlags, kPid, kPtr, kFlags, kPtr),
    MakeEntry(273, "ioprio_set", kFlags, kPid, kFlags),
    MakeEntry(274, "ioprio_get", kFlags, kUid),
    MakeEntry(275, "inotify_init"),
    MakeEntry(276, "inotify_add_watch", kResource, kPath, kFlags),
    MakeEntry(277, "inotify_rm_watch", kResource, kResource),
    MakeEntry(278, "spu_run", UnknownArguments()),
    MakeEntry(279, "spu_create", UnknownArguments()),
    MakeEntry(280, "pselect6", kLen1, kPtr, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(281, "ppoll", kPollFdArray, kLen0, kPtr, kPtr, kLen3),
    MakeEntry(282, "unshare", kFlags),
    MakeEntry(283, "splice", kResource, kPtr, kResource, kPtr, kInt, kFlags),
    MakeEntry(284, "tee", kResource, kResource, kInt, kFlags),
    MakeEntry(285, "vmsplice", kResource, kArray, kLen1, kFlags),
    MakeEntry(286, "openat", kResource, kPath, kFlags, kFlags),
    MakeEntry(287, "mkdirat", kResource, kPath, kFlags),
    MakeEntry(288, "mknodat", kResource, kPath, kFlags, kInt),
    MakeEntry(289, "fchownat", kResource, kPath, kUid, kGid, kFlags),
    MakeEntry(290, "futimesat", kResource, kPath, kPtr),
    MakeEntry(291, "newfstatat", kInt, kPath, kPtr, kFlags),
    MakeEntry(292, "unlinkat", kResource, kPath, kFlags),
    MakeEntry(293, "renameat", kResource, kPath, kResource, kPath),
    MakeEntry(294, "linkat", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(295, "symlinkat", kPath, kResource, kPath),
    MakeEntry(296, "readlinkat", kResource, kPath, kArray, kLen2),
    MakeEntry(297, "fchmodat", kResource, kPath, kFlags),
    MakeEntry(298, "faccessat", kResource, kPath, kFlags),
    MakeEntry(299, "get_robust_list", kPid, kPtr, kPtr),
    MakeEntry(300, "set_robust_list", kPtr, kLen0),
    MakeEntry(301, "move_pages", kPid, kLen2, kArray, kArray, kArray, kFlags),
    MakeEntry(302, "getcpu", kPtr, kPtr),
    MakeEntry(303, "epoll_pwait", kResource, kArray, kLen1, kInt, kPtr, kLen4),
    MakeEntry(304, "utimensat", kResource, kPath, kPtr, kFlags),
    MakeEntry(305, "signalfd", kResource, kPtr, kLen1),
    MakeEntry(306, "timerfd_create", kFlags, kFlags),
    MakeEntry(307, "eventfd", kInt),
    MakeEntry(308, "sync_file_range2", UnknownArguments()),
    MakeEntry(309, "fallocate", kResource, kFlags, kInt, kInt),
    MakeEntry(310, "subpage_prot", UnknownArguments()),
    MakeEntry(311, "timerfd_settime", kResource, kFlags, kPtr, kPtr),
    MakeEntry(312, "timerfd_gettime", kResource, kPtr),
    MakeEntry(313, "signalfd4", kResource, kPtr, kLen1, kFlags),
    MakeEntry(314, "eventfd2", kInt, kFlags),
    MakeEntry(315, "epoll_create1", kFlags),
    MakeEntry(316, "dup3", kResource, kResource, kFlags),
    MakeEntry(317, "pipe2", kPtr, kFlags),
    MakeEntry(318, "inotify_init1", kFlags),
    MakeEntry(319, "perf_event_open", kPtr, kPid, kInt, kResource, kFlags),
    MakeEntry(320, "preadv", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(321, "pwritev", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(322, "rt_tgsigqueueinfo", kPid, kPid, kSignal, kPtr),
    MakeEntry(323, "fanotify_init", kFlags, kFlags),
    MakeEntry(324, "fanotify_mark", kResource, kFlags, kFlags, kResource,
              kPath),
    MakeEntry(325, "prlimit64", kPid, kFlags, kPtr, kPtr),
    MakeEntry(326, "socket", kFlags, kFlags, kInt),
    MakeEntry(327, "bind", kResource, kSockaddr, kLen1),
    MakeEntry(328, "connect", kResource, kSockaddr, kLen1),
    MakeEntry(329, "listen", kResource, kInt),
    MakeEntry(330, "accept", kResource, kPtr, kPtr),
    MakeEntry(331, "getsockname", kResource, kPtr, kPtr),
    MakeEntry(332, "getpeername", kResource, kPtr, kPtr),
    MakeEntry(333, "socketpair", kFlags, kFlags, kInt, kPtr),
    MakeEntry(334, "send", UnknownArguments()),
    MakeEntry(335, "sendto", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(336, "recv", UnknownArguments()),
    MakeEntry(337, "recvfrom", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(338, "shutdown", kResource, kFlags),
    MakeEntry(339, "setsockopt", kResource, kFlags, kFlags, kArray, kLen3),
    MakeEntry(340, "getsockopt", kResource, kInt, kInt, kArray, kPtr),
    MakeEntry(341, "sendmsg", kResource, kPtr, kFlags),
    MakeEntry(342, "recvmsg", kResource, kPtr, kFlags),
    MakeEntry(343, "recvmmsg", kResource, kArray, kLen1, kFlags, kPtr),
    MakeEntry(344, "accept4", kResource, kPtr, kPtr, kFlags),
    MakeEntry(345, "name_to_handle_at", kResource, kPath, kPtr, kPtr, kFlags),
    MakeEntry(346, "open_by_handle_at", kResource, kPtr, kFlags),
    MakeEntry(347, "clock_adjtime", kFlags, kPtr),
    MakeEntry(348, "syncfs", kResource),
    MakeEntry(349, "sendmmsg", kResource, kArray, kLen1, kFlags),
    MakeEntry(350, "setns", kResource, kFlags),
    MakeEntry(351, "process_vm_readv", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(352, "process_vm_writev", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(353, "finit_module", kResource, kString, kFlags),
    MakeEntry(354, "kcmp", kPid, kPid, kFlags, kResource, kResource),
    MakeEntry(355, "sched_setattr", kPid, kPtr, kInt),
    MakeEntry(356, "sched_getattr", kPid, kPtr, kLen1, kInt),
    MakeEntry(357, "renameat2", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(358, "seccomp", kInt, kFlags, kPtr),
    MakeEntry(359, "getrandom", kArray, kLen0, kFlags),
    MakeEntry(360, "memfd_create", kString, kFlags),
    MakeEntry(361, "bpf", kSubcommand, kPtr, kLen1),
    MakeEntry(362, "execveat", kResource, kPath, kArray, kArray, kFlags),
    MakeEntry(363, "switch_endian", UnknownArguments()),
    MakeEntry(364, "userfaultfd", kFlags),
    MakeEntry(365, "membarrier", kSubcommand, kFlags),
    MakeEntry(378, "mlock2", kPtr, kLen0, kFlags),
    MakeEntry(379, "copy_file_range", kResource, kPtr, kResource, kPtr, kInt,
              kFlags),
    MakeEntry(380, "preadv2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(381, "pwritev2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(435, "clone3", kPtr, kLen0),
    MakeEntry(436, "close_range", kResource, kResource, kFlags),
    MakeEntry(437, "openat2", kResource, kPath, kPtr, kLen2),
    MakeEntry(438, "pidfd_getfd", kResource, kResource, kInt),
    MakeEntry(439, "faccessat2", kResource, kPath, kFlags, kFlags),
    MakeEntry(440, "process_madvise", kResource, kArray, kLen1, kFlags, kInt),
    MakeEntry(441, "epoll_pwait2", kResource, kArray, kLen1, kPtr, kPtr, kLen4),
    MakeEntry(442, "mount_setattr", kResource, kPath, kFlags, kPtr, kLen3),
    MakeEntry(443, "quotactl_fd", UnknownArguments()),
    MakeEntry(444, "landlock_create_ruleset", kPtr, kLen0, kInt),
    MakeEntry(445, "landlock_add_rule", kResource, kInt, kPtr, kInt),
    MakeEntry(446, "landlock_restrict_self", kResource, kInt),
    MakeEntry(448, "process_mrelease", kResource, kInt),
    MakeEntry(449, "futex_waitv", kArray, kLen0, kInt, kPtr, kFlags),
    MakeEntry(450, "set_mempolicy_home_node", kPtr, kLen0, kInt, kInt),
    MakeEntry(451, "cachestat", kResource, kPtr, kPtr, kInt),
    MakeEntry(452, "fchmodat2", kInt, kPath, kInt, kInt),
    MakeEntry(453, "map_shadow_stack", kPtr, kLen0, kFlags),
    MakeEntry(454, "futex_wake", UnknownArguments()),
    MakeEntry(455, "futex_wait", UnknownArguments()),
    MakeEntry(456, "futex_requeue", UnknownArguments()),
    MakeEntry(457, "statmount", UnknownArguments()),
    MakeEntry(458, "listmount", UnknownArguments()),
    MakeEntry(459, "lsm_get_self_attr", UnknownArguments()),
    MakeEntry(460, "lsm_set_self_attr", UnknownArguments()),
    MakeEntry(461, "lsm_list_modules", UnknownArguments()),
    // clang-format on
};

static_assert(IsSorted(kSyscallDataPPC64LE, SyscallTable::Entry::BySyscallNr),
              "Syscalls should be sorted");

// https://github.com/torvalds/linux/blob/v5.8/include/uapi/asm-generic/unistd.h
constexpr std::array kSyscallDataArm64 = {
    // clang-format off
    MakeEntry(0, "io_setup", kInt, kPtr),
    MakeEntry(1, "io_destroy", kStruct),
    MakeEntry(2, "io_submit", kStruct, kLen2, kArray),
    MakeEntry(3, "io_cancel", kStruct, kPtr, kPtr),
    MakeEntry(4, "io_getevents", kStruct, kInt, kLen3, kArray, kPtr),
    MakeEntry(5, "setxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(6, "lsetxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(7, "fsetxattr", kResource, kPtr, kString, kLen2, kFlags),
    MakeEntry(8, "getxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(9, "lgetxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(10, "fgetxattr", kResource, kPtr, kArray, kLen2),
    MakeEntry(11, "listxattr", kPath, kArray, kLen1),
    MakeEntry(12, "llistxattr", kPath, kArray, kLen1),
    MakeEntry(13, "flistxattr", kResource, kArray, kLen1),
    MakeEntry(14, "removexattr", kPath, kPtr),
    MakeEntry(15, "lremovexattr", kPath, kPtr),
    MakeEntry(16, "fremovexattr", kResource, kPtr),
    MakeEntry(17, "getcwd", kArray, kLen0),
    MakeEntry(18, "lookup_dcookie", kInt, kArray, kLen1),
    MakeEntry(19, "eventfd2", kInt, kFlags),
    MakeEntry(20, "epoll_create1", kFlags),
    MakeEntry(21, "epoll_ctl", kResource, kInt, kResource, kPtr),
    MakeEntry(22, "epoll_pwait", kResource, kArray, kLen1, kInt, kPtr, kLen4),
    MakeEntry(23, "dup", kResource),
    MakeEntry(24, "dup3", kResource, kResource, kFlags),
    MakeEntry(25, "fcntl", kResource, kSubcommand, kResource),
    MakeEntry(26, "inotify_init1", kFlags),
    MakeEntry(27, "inotify_add_watch", kResource, kPath, kFlags),
    MakeEntry(28, "inotify_rm_watch", kResource, kResource),
    MakeEntry(29, "ioctl", kResource, kSubcommand, kArray),
    MakeEntry(30, "ioprio_set", kFlags, kPid, kFlags),
    MakeEntry(31, "ioprio_get", kFlags, kUid),
    MakeEntry(32, "flock", kResource, kFlags),
    MakeEntry(33, "mknodat", kResource, kPath, kFlags, kInt),
    MakeEntry(34, "mkdirat", kResource, kPath, kFlags),
    MakeEntry(35, "unlinkat", kResource, kPath, kFlags),
    MakeEntry(36, "symlinkat", kPath, kResource, kPath),
    MakeEntry(37, "linkat", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(38, "renameat", kResource, kPath, kResource, kPath),
    MakeEntry(39, "umount2", kPath, kFlags),
    MakeEntry(40, "mount", kPtr, kPath, kString, kFlags, kString),
    MakeEntry(41, "pivot_root", kPath, kPath),
    MakeEntry(42, "nfsservctl", kSubcommand, kPtr, kPtr),
    MakeEntry(43, "statfs", kPath, kArray),
    MakeEntry(44, "fstatfs", kResource, kArray),
    MakeEntry(45, "truncate", kPath, kInt),
    MakeEntry(46, "ftruncate", kResource, kInt),
    MakeEntry(47, "fallocate", kResource, kFlags, kInt, kInt),
    MakeEntry(48, "faccessat", kResource, kPath, kFlags),
    MakeEntry(49, "chdir", kPath),
    MakeEntry(50, "fchdir", kResource),
    MakeEntry(51, "chroot", kPath),
    MakeEntry(52, "fchmod", kResource, kFlags),
    MakeEntry(53, "fchmodat", kResource, kPath, kFlags),
    MakeEntry(54, "fchownat", kResource, kPath, kUid, kGid, kFlags),
    MakeEntry(55, "fchown", kResource, kUid, kGid),
    MakeEntry(56, "openat", kResource, kPath, kFlags, kFlags),
    MakeEntry(57, "close", kResource),
    MakeEntry(58, "vhangup"),
    MakeEntry(59, "pipe2", kPtr, kFlags),
    MakeEntry(60, "quotactl", kSubcommand, kPath, kInt, kGen),
    MakeEntry(61, "getdents64", kResource, kArray, kLen1),
    MakeEntry(62, "lseek", kResource, kInt, kFlags),
    MakeEntry(63, "read", kResource, kArray, kLen1),
    MakeEntry(64, "write", kResource, kArray, kLen1),
    MakeEntry(65, "readv", kResource, kArray, kLen1),
    MakeEntry(66, "writev", kResource, kArray, kLen1),
    MakeEntry(67, "pread64", kResource, kArray, kLen1, kInt),
    MakeEntry(68, "pwrite64", kResource, kArray, kLen1, kInt),
    MakeEntry(69, "preadv", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(70, "pwritev", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(71, "sendfile", kResource, kResource, kPtr, kInt),
    MakeEntry(72, "pselect6", kLen1, kPtr, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(73, "ppoll", kPollFdArray, kLen0, kPtr, kPtr, kLen3),
    MakeEntry(74, "signalfd4", kResource, kPtr, kLen1, kFlags),
    MakeEntry(75, "vmsplice", kResource, kArray, kLen1, kFlags),
    MakeEntry(76, "splice", kResource, kPtr, kResource, kPtr, kInt, kFlags),
    MakeEntry(77, "tee", kResource, kResource, kInt, kFlags),
    MakeEntry(78, "readlinkat", kResource, kPath, kArray, kLen2),
    MakeEntry(79, "newfstatat", kInt, kPath, kPtr, kFlags),
    MakeEntry(80, "fstat", kResource, kPtr),
    MakeEntry(81, "sync"),
    MakeEntry(82, "fsync", kResource),
    MakeEntry(83, "fdatasync", kResource),
    MakeEntry(84, "sync_file_range", kResource, kInt, kInt, kFlags),
    MakeEntry(85, "timerfd_create", kFlags, kFlags),
    MakeEntry(86, "timerfd_settime", kResource, kFlags, kPtr, kPtr),
    MakeEntry(87, "timerfd_gettime", kResource, kPtr),
    MakeEntry(88, "utimensat", kResource, kPath, kPtr, kFlags),
    MakeEntry(89, "acct", kPath),
    MakeEntry(90, "capget", kPtr, kPtr),
    MakeEntry(91, "capset", kPtr, kPtr),
    MakeEntry(92, "personality", kFlags),
    MakeEntry(93, "exit", kInt),
    MakeEntry(94, "exit_group", kInt),
    MakeEntry(95, "waitid", kFlags, kPid, kPtr, kFlags, kPtr),
    MakeEntry(96, "set_tid_address", kPtr),
    MakeEntry(97, "unshare", kFlags),
    MakeEntry(98, "futex", kPtr, kFlags, kInt, kPtr, kPtr, kInt),
    MakeEntry(99, "set_robust_list", kPtr, kLen0),
    MakeEntry(100, "get_robust_list", kPid, kPtr, kPtr),
    MakeEntry(101, "nanosleep", kPtr, kPtr),
    MakeEntry(102, "getitimer", kFlags, kPtr),
    MakeEntry(103, "setitimer", kFlags, kPtr, kPtr),
    MakeEntry(104, "kexec_load", kInt, kLen2, kArray, kFlags),
    MakeEntry(105, "init_module", kString, kLen0, kString),
    MakeEntry(106, "delete_module", kString, kFlags),
    MakeEntry(107, "timer_create", kFlags, kPtr, kPtr),
    MakeEntry(108, "timer_gettime", kStruct, kPtr),
    MakeEntry(109, "timer_getoverrun", kStruct),
    MakeEntry(110, "timer_settime", kStruct, kFlags, kPtr, kPtr),
    MakeEntry(111, "timer_delete", kStruct),
    MakeEntry(112, "clock_settime", kFlags, kPtr),
    MakeEntry(113, "clock_gettime", kFlags, kPtr),
    MakeEntry(114, "clock_getres", kFlags, kPtr),
    MakeEntry(115, "clock_nanosleep", kFlags, kFlags, kPtr, kPtr),
    MakeEntry(116, "syslog", kSubcommand, kArray, kLen1),
    MakeEntry(117, "ptrace", kFlags, kPid),
    MakeEntry(118, "sched_setparam", kPid, kPtr),
    MakeEntry(119, "sched_setscheduler", kPid, kFlags, kPtr),
    MakeEntry(120, "sched_getscheduler", kPid),
    MakeEntry(121, "sched_getparam", kPid, kPtr),
    MakeEntry(122, "sched_setaffinity", kPid, kLen2, kPtr),
    MakeEntry(123, "sched_getaffinity", kPid, kLen2, kPtr),
    MakeEntry(124, "sched_yield"),
    MakeEntry(125, "sched_get_priority_max", kInt),
    MakeEntry(126, "sched_get_priority_min", kInt),
    MakeEntry(127, "sched_rr_get_interval", kPid, kPtr),
    MakeEntry(128, "restart_syscall"),
    MakeEntry(129, "kill", kPid, kSignal),
    MakeEntry(130, "tkill", kPid, kSignal),
    MakeEntry(131, "tgkill", kPid, kPid, kSignal),
    MakeEntry(132, "sigaltstack", kPtr, kPtr),
    MakeEntry(133, "rt_sigsuspend", kPtr, kLen0),
    MakeEntry(134, "rt_sigaction", kSignal, kPtr, kPtr, kLen4, kPtr),
    MakeEntry(135, "rt_sigprocmask", kFlags, kPtr, kPtr, kLen1),
    MakeEntry(136, "rt_sigpending", kPtr, kLen0),
    MakeEntry(137, "rt_sigtimedwait", kPtr, kPtr, kPtr, kLen0),
    MakeEntry(138, "rt_sigqueueinfo", kPid, kSignal, kPtr),
    MakeEntry(139, "rt_sigreturn"),
    MakeEntry(140, "setpriority", kFlags, kPid, kInt),
    MakeEntry(141, "getpriority", kFlags, kPid),
    MakeEntry(142, "reboot", kInt, kInt, kSubcommand, kPtr),
    MakeEntry(143, "setregid", kGid, kGid),
    MakeEntry(144, "setgid", kGid),
    MakeEntry(145, "setreuid", kUid, kUid),
    MakeEntry(146, "setuid", kUid),
    MakeEntry(147, "setresuid", kUid, kUid, kUid),
    MakeEntry(148, "getresuid", kPtr, kPtr, kPtr),
    MakeEntry(149, "setresgid", kGid, kGid, kGid),
    MakeEntry(150, "getresgid", kPtr, kPtr, kPtr),
    MakeEntry(151, "setfsuid", kUid),
    MakeEntry(152, "setfsgid", kGid),
    MakeEntry(153, "times", kPtr),
    MakeEntry(154, "setpgid", kPid, kPid),
    MakeEntry(155, "getpgid", kPid),
    MakeEntry(156, "getsid", kPid),
    MakeEntry(157, "setsid"),
    MakeEntry(158, "getgroups", kLen1, kGidArray),
    MakeEntry(159, "setgroups", kLen1, kGidArray),
    MakeEntry(160, "uname", kArray),
    MakeEntry(161, "sethostname", kString, kLen0),
    MakeEntry(162, "setdomainname", kString, kLen0),
    MakeEntry(163, "getrlimit", kFlags, kPtr),
    MakeEntry(164, "setrlimit", kFlags, kPtr),
    MakeEntry(165, "getrusage", kFlags, kPtr),
    MakeEntry(166, "umask", kFlags),
    MakeEntry(167, "prctl", kSubcommand, kSubcommand, kInt, kInt, kInt),
    MakeEntry(168, "getcpu", kPtr, kPtr),
    MakeEntry(169, "gettimeofday", kPtr, kPtr),
    MakeEntry(170, "settimeofday", kPtr, kPtr),
    MakeEntry(171, "adjtimex", kArray),
    MakeEntry(172, "getpid"),
    MakeEntry(173, "getppid"),
    MakeEntry(174, "getuid"),
    MakeEntry(175, "geteuid"),
    MakeEntry(176, "getgid"),
    MakeEntry(177, "getegid"),
    MakeEntry(178, "gettid"),
    MakeEntry(179, "sysinfo", kArray),
    MakeEntry(180, "mq_open", kString, kFlags, kFlags, kPtr),
    MakeEntry(181, "mq_unlink", kString),
    MakeEntry(182, "mq_timedsend", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(183, "mq_timedreceive", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(184, "mq_notify", kResource, kPtr),
    MakeEntry(185, "mq_getsetattr", kResource, kPtr, kPtr),
    MakeEntry(186, "msgget", kIpcResource, kFlags),
    MakeEntry(187, "msgctl", kIpcResource, kSubcommand, kArray),
    MakeEntry(188, "msgrcv", kIpcResource, kPtr, kLen1, kFlags, kFlags),
    MakeEntry(189, "msgsnd", kIpcResource, kPtr, kLen1, kFlags),
    MakeEntry(190, "semget", kIpcResource, kFlags, kFlags),
    MakeEntry(191, "semctl", kIpcResource, kFlags, kSubcommand, kArray),
    MakeEntry(192, "semtimedop", kIpcResource, kArray, kLen1, kPtr),
    MakeEntry(193, "semop", kIpcResource, kArray, kLen1),
    MakeEntry(194, "shmget", kInt, kLen3, kFlags, kPtr),
    MakeEntry(195, "shmctl", kIpcResource, kSubcommand, kArray),
    MakeEntry(196, "shmat", kIpcResource, kPtr, kFlags),
    MakeEntry(197, "shmdt", kSharedAddress),
    MakeEntry(198, "socket", kFlags, kFlags, kInt),
    MakeEntry(199, "socketpair", kFlags, kFlags, kInt, kPtr),
    MakeEntry(200, "bind", kResource, kSockaddr, kLen1),
    MakeEntry(201, "listen", kResource, kInt),
    MakeEntry(202, "accept", kResource, kPtr, kPtr),
    MakeEntry(203, "connect", kResource, kSockaddr, kLen1),
    MakeEntry(204, "getsockname", kResource, kPtr, kPtr),
    MakeEntry(205, "getpeername", kResource, kPtr, kPtr),
    MakeEntry(206, "sendto", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(207, "recvfrom", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(208, "setsockopt", kResource, kFlags, kFlags, kArray, kLen3),
    MakeEntry(209, "getsockopt", kResource, kInt, kInt, kArray, kPtr),
    MakeEntry(210, "shutdown", kResource, kFlags),
    MakeEntry(211, "sendmsg", kResource, kPtr, kFlags),
    MakeEntry(212, "recvmsg", kResource, kPtr, kFlags),
    MakeEntry(213, "readahead", kResource, kInt, kInt),
    MakeEntry(214, "brk", kInt),
    MakeEntry(215, "munmap", kPtr, kLen0),
    MakeEntry(216, "mremap", kPtr, kLen0, kLen4, kFlags, kPtr),
    MakeEntry(217, "add_key", kString, kPtr, kArray, kLen2, kStruct),
    MakeEntry(218, "request_key", kString, kPtr, kString, kStruct),
    MakeEntry(219, "keyctl", kInt, kInt, kInt, kInt, kInt),
    MakeEntry(220, "clone", kFlags, kArray, kPtr, kPtr, kArray),
    MakeEntry(221, "execve", kPath, kArray, kArray),
    MakeEntry(222, "mmap", kPtr, kLen0, kFlags, kFlags, kResource, kInt),
    MakeEntry(223, "fadvise64", kResource, kInt, kInt, kFlags),
    MakeEntry(224, "swapon", kPath, kFlags),
    MakeEntry(225, "swapoff", kPath),
    MakeEntry(226, "mprotect", kPtr, kLen0, kFlags),
    MakeEntry(227, "msync", kPtr, kLen0, kFlags),
    MakeEntry(228, "mlock", kPtr, kLen0),
    MakeEntry(229, "munlock", kPtr, kLen0),
    MakeEntry(230, "mlockall", kFlags),
    MakeEntry(231, "munlockall"),
    MakeEntry(232, "mincore", kPtr, kLen0, kArray),
    MakeEntry(233, "madvise", kPtr, kLen0, kFlags),
    MakeEntry(234, "remap_file_pages", kPtr, kLen0, kFlags, kInt, kFlags),
    MakeEntry(235, "mbind", kPtr, kLen0, kFlags, kPtr, kInt, kFlags),
    MakeEntry(236, "get_mempolicy", kPtr, kPtr, kInt, kPtr, kFlags),
    MakeEntry(237, "set_mempolicy", kFlags, kPtr, kInt),
    MakeEntry(238, "migrate_pages", kPid, kInt, kPtr, kPtr),
    MakeEntry(239, "move_pages", kPid, kLen2, kArray, kArray, kArray, kFlags),
    MakeEntry(240, "rt_tgsigqueueinfo", kPid, kPid, kSignal, kPtr),
    MakeEntry(241, "perf_event_open", kPtr, kPid, kInt, kResource, kFlags),
    MakeEntry(242, "accept4", kResource, kPtr, kPtr, kFlags),
    MakeEntry(243, "recvmmsg", kResource, kArray, kLen1, kFlags, kPtr),
    MakeEntry(260, "wait4", kPid, kPtr, kFlags, kPtr),
    MakeEntry(261, "prlimit64", kPid, kFlags, kPtr, kPtr),
    MakeEntry(262, "fanotify_init", kFlags, kFlags),
    MakeEntry(263, "fanotify_mark", kResource, kFlags, kFlags, kResource,
              kPath),
    MakeEntry(264, "name_to_handle_at", kResource, kPath, kPtr, kPtr, kFlags),
    MakeEntry(265, "open_by_handle_at", kResource, kPtr, kFlags),
    MakeEntry(266, "clock_adjtime", kFlags, kPtr),
    MakeEntry(267, "syncfs", kResource),
    MakeEntry(268, "setns", kResource, kFlags),
    MakeEntry(269, "sendmmsg", kResource, kArray, kLen1, kFlags),
    MakeEntry(270, "process_vm_readv", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(271, "process_vm_writev", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(272, "kcmp", kPid, kPid, kFlags, kResource, kResource),
    MakeEntry(273, "finit_module", kResource, kString, kFlags),
    MakeEntry(274, "sched_setattr", kPid, kPtr, kInt),
    MakeEntry(275, "sched_getattr", kPid, kPtr, kLen1, kInt),
    MakeEntry(276, "renameat2", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(277, "seccomp", kInt, kFlags, kPtr),
    MakeEntry(278, "getrandom", kArray, kLen0, kFlags),
    MakeEntry(279, "memfd_create", kString, kFlags),
    MakeEntry(280, "bpf", kSubcommand, kPtr, kLen1),
    MakeEntry(281, "execveat", kResource, kPath, kArray, kArray, kFlags),
    MakeEntry(282, "userfaultfd", kFlags),
    MakeEntry(283, "membarrier", kSubcommand, kFlags),
    MakeEntry(284, "mlock2", kPtr, kLen0, kFlags),
    MakeEntry(285, "copy_file_range", kResource, kPtr, kResource, kPtr, kInt,
              kFlags),
    MakeEntry(286, "preadv2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(287, "pwritev2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(435, "clone3", kPtr, kLen0),
    MakeEntry(436, "close_range", kResource, kResource, kFlags),
    MakeEntry(437, "openat2", kResource, kPath, kPtr, kLen2),
    MakeEntry(438, "pidfd_getfd", kResource, kResource, kInt),
    MakeEntry(439, "faccessat2", kResource, kPath, kFlags, kFlags),
    MakeEntry(440, "process_madvise", kResource, kArray, kLen1, kFlags, kInt),
    MakeEntry(441, "epoll_pwait2", kResource, kArray, kLen1, kPtr, kPtr, kLen4),
    MakeEntry(442, "mount_setattr", kResource, kPath, kFlags, kPtr, kLen3),
    MakeEntry(443, "quotactl_fd", UnknownArguments()),
    MakeEntry(444, "landlock_create_ruleset", kPtr, kLen0, kInt),
    MakeEntry(445, "landlock_add_rule", kResource, kInt, kPtr, kInt),
    MakeEntry(446, "landlock_restrict_self", kResource, kInt),
    MakeEntry(448, "process_mrelease", kResource, kInt),
    MakeEntry(449, "futex_waitv", kArray, kLen0, kInt, kPtr, kFlags),
    MakeEntry(450, "set_mempolicy_home_node", kPtr, kLen0, kInt, kInt),
    MakeEntry(451, "cachestat", kResource, kPtr, kPtr, kInt),
    MakeEntry(452, "fchmodat2", kInt, kPath, kInt, kInt),
    MakeEntry(453, "map_shadow_stack", kPtr, kLen0, kFlags),
    MakeEntry(454, "futex_wake", UnknownArguments()),
    MakeEntry(455, "futex_wait", UnknownArguments()),
    MakeEntry(456, "futex_requeue", UnknownArguments()),
    MakeEntry(457, "statmount", UnknownArguments()),
    MakeEntry(458, "listmount", UnknownArguments()),
    MakeEntry(459, "lsm_get_self_attr", UnknownArguments()),
    MakeEntry(460, "lsm_set_self_attr", UnknownArguments()),
    MakeEntry(461, "lsm_list_modules", UnknownArguments()),
    // clang-format on
};

static_assert(IsSorted(kSyscallDataArm64, SyscallTable::Entry::BySyscallNr),
              "Syscalls should be sorted");

constexpr std::array kSyscallDataArm32 = {
    // clang-format off
    MakeEntry(0, "restart_syscall"),
    MakeEntry(1, "exit", kInt),
    MakeEntry(2, "fork"),
    MakeEntry(3, "read", kResource, kArray, kLen1),
    MakeEntry(4, "write", kResource, kArray, kLen1),
    MakeEntry(5, "open", kPath, kFlags, kFlags),
    MakeEntry(6, "close", kResource),
    MakeEntry(8, "creat", kPath, kFlags),
    MakeEntry(9, "link", kPath, kPath),
    MakeEntry(10, "unlink", kPath),
    MakeEntry(11, "execve", kPath, kArray, kArray),
    MakeEntry(12, "chdir", kPath),
    MakeEntry(14, "mknod", kPath, kFlags, kInt),
    MakeEntry(15, "chmod", kPath, kFlags),
    MakeEntry(16, "lchown", kPath, kUid, kGid),
    MakeEntry(19, "lseek", kResource, kInt, kFlags),
    MakeEntry(20, "getpid"),
    MakeEntry(21, "mount", kPtr, kPath, kString, kFlags, kString),
    MakeEntry(23, "setuid", kUid),
    MakeEntry(24, "getuid"),
    MakeEntry(26, "ptrace", kFlags, kPid),
    MakeEntry(29, "pause"),
    MakeEntry(33, "access", kPath, kInt),
    MakeEntry(34, "nice", kInt, kInt, kInt, kInt),
    MakeEntry(36, "sync"),
    MakeEntry(37, "kill", kPid, kSignal),
    MakeEntry(38, "rename", kPath, kPath),
    MakeEntry(39, "mkdir", kPath, kFlags),
    MakeEntry(40, "rmdir", kPath),
    MakeEntry(41, "dup", kResource),
    MakeEntry(42, "pipe", kPtr),
    MakeEntry(43, "times", kPtr),
    MakeEntry(45, "brk", kInt),
    MakeEntry(46, "setgid", kGid),
    MakeEntry(47, "getgid"),
    MakeEntry(49, "geteuid"),
    MakeEntry(50, "getegid"),
    MakeEntry(51, "acct", kPath),
    MakeEntry(52, "umount2", kPath, kFlags),
    MakeEntry(54, "ioctl", kResource, kSubcommand, kArray),
    MakeEntry(55, "fcntl", kResource, kSubcommand, kResource),
    MakeEntry(57, "setpgid", kPid, kPid),
    MakeEntry(60, "umask", kFlags),
    MakeEntry(61, "chroot", kPath),
    MakeEntry(62, "ustat", kInt, kPtr),
    MakeEntry(63, "dup2", kResource, kResource),
    MakeEntry(64, "getppid"),
    MakeEntry(65, "getpgrp", kPid),
    MakeEntry(66, "setsid"),
    MakeEntry(67, "sigaction", kInt, kInt, kInt, kInt),
    MakeEntry(70, "setreuid", kUid, kUid),
    MakeEntry(71, "setregid", kGid, kGid),
    MakeEntry(72, "sigsuspend", kInt, kInt, kInt, kInt),
    MakeEntry(73, "sigpending", kInt, kInt, kInt, kInt),
    MakeEntry(74, "sethostname", kString, kLen0),
    MakeEntry(75, "setrlimit", kFlags, kPtr),
    MakeEntry(77, "getrusage", kFlags, kPtr),
    MakeEntry(78, "gettimeofday", kPtr, kPtr),
    MakeEntry(79, "settimeofday", kPtr, kPtr),
    MakeEntry(80, "getgroups", kLen1, kGidArray),
    MakeEntry(81, "setgroups", kLen1, kGidArray),
    MakeEntry(83, "symlink", kPath, kPath),
    MakeEntry(85, "readlink", kPath, kArray, kLen1),
    MakeEntry(86, "uselib", kPath),
    MakeEntry(87, "swapon", kPath, kFlags),
    MakeEntry(88, "reboot", kInt, kInt, kSubcommand, kPtr),
    MakeEntry(91, "munmap", kPtr, kLen0),
    MakeEntry(92, "truncate", kPath, kInt),
    MakeEntry(93, "ftruncate", kResource, kInt),
    MakeEntry(94, "fchmod", kResource, kFlags),
    MakeEntry(95, "fchown", kResource, kUid, kGid),
    MakeEntry(96, "getpriority", kFlags, kPid),
    MakeEntry(97, "setpriority", kFlags, kPid, kInt),
    MakeEntry(99, "statfs", kPath, kArray),
    MakeEntry(100, "fstatfs", kResource, kArray),
    MakeEntry(103, "syslog", kSubcommand, kArray, kLen1),
    MakeEntry(104, "setitimer", kFlags, kPtr, kPtr),
    MakeEntry(105, "getitimer", kFlags, kPtr),
    MakeEntry(106, "stat", kPath, kPtr),
    MakeEntry(107, "lstat", kPath, kPtr),
    MakeEntry(108, "fstat", kResource, kPtr),
    MakeEntry(111, "vhangup"),
    MakeEntry(114, "wait4", kPid, kPtr, kFlags, kPtr),
    MakeEntry(115, "swapoff", kPath),
    MakeEntry(116, "sysinfo", kArray),
    MakeEntry(118, "fsync", kResource),
    MakeEntry(119, "sigreturn", kInt, kInt, kInt, kInt),
    MakeEntry(120, "clone", kFlags, kArray, kPtr, kPtr, kArray),
    MakeEntry(121, "setdomainname", kString, kLen0),
    MakeEntry(122, "uname", kArray),
    MakeEntry(124, "adjtimex", kArray),
    MakeEntry(125, "mprotect", kPtr, kLen0, kFlags),
    MakeEntry(126, "sigprocmask", kInt, kInt, kInt, kInt),
    MakeEntry(128, "init_module", kString, kLen0, kString),
    MakeEntry(129, "delete_module", kString, kFlags),
    MakeEntry(131, "quotactl", kSubcommand, kInt, kInt, kInt),
    MakeEntry(132, "getpgid", kPid),
    MakeEntry(133, "fchdir", kResource),
    MakeEntry(134, "bdflush", kInt, kInt, kInt, kInt),
    MakeEntry(135, "sysfs", kInt, kString),
    MakeEntry(136, "personality", kFlags),
    MakeEntry(138, "setfsuid", kUid),
    MakeEntry(139, "setfsgid", kGid),
    MakeEntry(140, "_llseek", kInt, kInt, kInt, kInt),
    MakeEntry(141, "getdents", kResource, kArray, kLen1),
    MakeEntry(142, "_newselect", kInt, kInt, kInt, kInt),
    MakeEntry(143, "flock", kResource, kFlags),
    MakeEntry(144, "msync", kPtr, kLen0, kFlags),
    MakeEntry(145, "readv", kResource, kArray, kLen1),
    MakeEntry(146, "writev", kResource, kArray, kLen1),
    MakeEntry(147, "getsid", kPid),
    MakeEntry(148, "fdatasync", kResource),
    MakeEntry(149, "_sysctl", kPtr),
    MakeEntry(150, "mlock", kPtr, kLen0),
    MakeEntry(151, "munlock", kPtr, kLen0),
    MakeEntry(152, "mlockall", kFlags),
    MakeEntry(153, "munlockall"),
    MakeEntry(154, "sched_setparam", kPid, kPtr),
    MakeEntry(155, "sched_getparam", kPid, kPtr),
    MakeEntry(156, "sched_setscheduler", kPid, kFlags, kPtr),
    MakeEntry(157, "sched_getscheduler", kPid),
    MakeEntry(158, "sched_yield"),
    MakeEntry(159, "sched_get_priority_max", kInt),
    MakeEntry(160, "sched_get_priority_min", kInt),
    MakeEntry(161, "sched_rr_get_interval", kPid, kPtr),
    MakeEntry(162, "nanosleep", kPtr, kPtr),
    MakeEntry(163, "mremap", kPtr, kLen0, kLen4, kFlags, kPtr),
    MakeEntry(164, "setresuid", kUid, kUid, kUid),
    MakeEntry(165, "getresuid", kPtr, kPtr, kPtr),
    MakeEntry(168, "poll", kPollFdArray, kLen0, kInt),
    MakeEntry(169, "nfsservctl", kSubcommand, kPtr, kPtr),
    MakeEntry(170, "setresgid", kGid, kGid, kGid),
    MakeEntry(171, "getresgid", kPtr, kPtr, kPtr),
    MakeEntry(172, "prctl", kSubcommand, kSubcommand, kInt, kInt, kInt),
    MakeEntry(173, "rt_sigreturn"),
    MakeEntry(174, "rt_sigaction", kSignal, kPtr, kPtr, kLen4, kPtr),
    MakeEntry(175, "rt_sigprocmask", kFlags, kPtr, kPtr, kLen1),
    MakeEntry(176, "rt_sigpending", kPtr, kLen0),
    MakeEntry(177, "rt_sigtimedwait", kPtr, kPtr, kPtr, kLen0),
    MakeEntry(178, "rt_sigqueueinfo", kPid, kSignal, kPtr),
    MakeEntry(179, "rt_sigsuspend", kPtr, kLen0),
    MakeEntry(180, "pread64", kResource, kArray, kLen1, kInt),
    MakeEntry(181, "pwrite64", kResource, kArray, kLen1, kInt),
    MakeEntry(182, "chown", kPath, kUid, kGid),
    MakeEntry(183, "getcwd", kArray, kLen0),
    MakeEntry(184, "capget", kPtr, kPtr),
    MakeEntry(185, "capset", kPtr, kPtr),
    MakeEntry(186, "sigaltstack", kPtr, kPtr),
    MakeEntry(187, "sendfile", kResource, kResource, kPtr, kInt),
    MakeEntry(190, "vfork"),
    MakeEntry(191, "ugetrlimit", kInt, kInt, kInt, kInt),
    MakeEntry(192, "mmap2", kInt, kInt, kInt, kInt),
    MakeEntry(193, "truncate64", kInt, kInt, kInt, kInt),
    MakeEntry(194, "ftruncate64", kInt, kInt, kInt, kInt),
    MakeEntry(195, "stat64", kPath, kPtr),
    MakeEntry(196, "lstat64", kPath, kPtr),
    MakeEntry(197, "fstat64", kResource, kPtr),
    MakeEntry(198, "lchown32", kInt, kInt, kInt, kInt),
    MakeEntry(199, "getuid32", kInt, kInt, kInt, kInt),
    MakeEntry(200, "getgid32", kInt, kInt, kInt, kInt),
    MakeEntry(201, "geteuid32", kInt, kInt, kInt, kInt),
    MakeEntry(202, "getegid32", kInt, kInt, kInt, kInt),
    MakeEntry(203, "setreuid32", kInt, kInt, kInt, kInt),
    MakeEntry(204, "setregid32", kInt, kInt, kInt, kInt),
    MakeEntry(205, "getgroups32", kInt, kInt, kInt, kInt),
    MakeEntry(206, "setgroups32", kInt, kInt, kInt, kInt),
    MakeEntry(207, "fchown32", kInt, kInt, kInt, kInt),
    MakeEntry(208, "setresuid32", kInt, kInt, kInt, kInt),
    MakeEntry(209, "getresuid32", kInt, kInt, kInt, kInt),
    MakeEntry(210, "setresgid32", kInt, kInt, kInt, kInt),
    MakeEntry(211, "getresgid32", kInt, kInt, kInt, kInt),
    MakeEntry(212, "chown32", kInt, kInt, kInt, kInt),
    MakeEntry(213, "setuid32", kInt, kInt, kInt, kInt),
    MakeEntry(214, "setgid32", kInt, kInt, kInt, kInt),
    MakeEntry(215, "setfsuid32", kInt, kInt, kInt, kInt),
    MakeEntry(216, "setfsgid32", kInt, kInt, kInt, kInt),
    MakeEntry(217, "getdents64", kResource, kArray, kLen1),
    MakeEntry(218, "pivot_root", kPath, kPath),
    MakeEntry(219, "mincore", kPtr, kLen0, kArray),
    MakeEntry(220, "madvise", kPtr, kLen0, kFlags),
    MakeEntry(221, "fcntl64", kResource, kSubcommand, kInt, kInt),
    MakeEntry(224, "gettid"),
    MakeEntry(225, "readahead", kResource, kInt, kInt),
    MakeEntry(226, "setxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(227, "lsetxattr", kPath, kPtr, kString, kLen2, kFlags),
    MakeEntry(228, "fsetxattr", kResource, kPtr, kString, kLen2, kFlags),
    MakeEntry(229, "getxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(230, "lgetxattr", kPath, kPtr, kArray, kLen2),
    MakeEntry(231, "fgetxattr", kResource, kPtr, kArray, kLen2),
    MakeEntry(232, "listxattr", kPath, kArray, kLen1),
    MakeEntry(233, "llistxattr", kPath, kArray, kLen1),
    MakeEntry(234, "flistxattr", kResource, kArray, kLen1),
    MakeEntry(235, "removexattr", kPath, kPtr),
    MakeEntry(236, "lremovexattr", kPath, kPtr),
    MakeEntry(237, "fremovexattr", kResource, kPtr),
    MakeEntry(238, "tkill", kPid, kSignal),
    MakeEntry(239, "sendfile64", kResource, kResource, kPtr, kInt),
    MakeEntry(240, "futex", kPtr, kFlags, kInt, kPtr, kPtr, kInt),
    MakeEntry(241, "sched_setaffinity", kPid, kLen2, kPtr),
    MakeEntry(242, "sched_getaffinity", kPid, kLen2, kPtr),
    MakeEntry(243, "io_setup", kInt, kPtr),
    MakeEntry(244, "io_destroy", kStruct),
    MakeEntry(245, "io_getevents", kStruct, kInt, kLen3, kArray, kPtr),
    MakeEntry(246, "io_submit", kStruct, kLen2, kArray),
    MakeEntry(247, "io_cancel", kStruct, kPtr, kPtr),
    MakeEntry(248, "exit_group", kInt),
    MakeEntry(249, "lookup_dcookie", kInt, kArray, kLen1),
    MakeEntry(250, "epoll_create", kInt),
    MakeEntry(251, "epoll_ctl", kResource, kInt, kResource, kPtr),
    MakeEntry(252, "epoll_wait", kResource, kArray, kLen1, kInt),
    MakeEntry(253, "remap_file_pages", kPtr, kLen0, kFlags, kInt, kFlags),
    MakeEntry(256, "set_tid_address", kPtr),
    MakeEntry(257, "timer_create", kFlags, kPtr, kPtr),
    MakeEntry(258, "timer_settime", kStruct, kFlags, kPtr, kPtr),
    MakeEntry(259, "timer_gettime", kStruct, kPtr),
    MakeEntry(260, "timer_getoverrun", kStruct),
    MakeEntry(261, "timer_delete", kStruct),
    MakeEntry(262, "clock_settime", kFlags, kPtr),
    MakeEntry(263, "clock_gettime", kFlags, kPtr),
    MakeEntry(264, "clock_getres", kFlags, kPtr),
    MakeEntry(265, "clock_nanosleep", kFlags, kFlags, kPtr, kPtr),
    MakeEntry(266, "statfs64", kInt, kInt, kInt, kInt),
    MakeEntry(267, "fstatfs64", kInt, kInt, kInt, kInt),
    MakeEntry(268, "tgkill", kPid, kPid, kSignal),
    MakeEntry(269, "utimes", kPath, kPtr),
    MakeEntry(271, "pciconfig_iobase", kInt, kInt, kInt, kInt),
    MakeEntry(272, "pciconfig_read", kInt, kInt, kInt, kInt),
    MakeEntry(273, "pciconfig_write", kInt, kInt, kInt, kInt),
    MakeEntry(274, "mq_open", kString, kFlags, kFlags, kPtr),
    MakeEntry(275, "mq_unlink", kString),
    MakeEntry(276, "mq_timedsend", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(277, "mq_timedreceive", kResource, kArray, kLen1, kInt, kPtr),
    MakeEntry(278, "mq_notify", kResource, kPtr),
    MakeEntry(279, "mq_getsetattr", kResource, kPtr, kPtr),
    MakeEntry(280, "waitid", kFlags, kPid, kPtr, kFlags, kPtr),
    MakeEntry(281, "socket", kFlags, kFlags, kInt),
    MakeEntry(282, "bind", kResource, kSockaddr, kLen1),
    MakeEntry(283, "connect", kResource, kSockaddr, kLen1),
    MakeEntry(284, "listen", kResource, kInt),
    MakeEntry(285, "accept", kResource, kPtr, kPtr),
    MakeEntry(286, "getsockname", kResource, kPtr, kPtr),
    MakeEntry(287, "getpeername", kResource, kPtr, kPtr),
    MakeEntry(288, "socketpair", kFlags, kFlags, kInt, kPtr),
    MakeEntry(289, "send", kInt, kInt, kInt, kInt),
    MakeEntry(290, "sendto", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(291, "recv", kInt, kInt, kInt, kInt),
    MakeEntry(292, "recvfrom", kResource, kArray, kLen1, kFlags, kSockaddr,
              kLen4),
    MakeEntry(293, "shutdown", kResource, kFlags),
    MakeEntry(294, "setsockopt", kResource, kFlags, kFlags, kArray, kLen3),
    MakeEntry(295, "getsockopt", kResource, kInt, kInt, kArray, kPtr),
    MakeEntry(296, "sendmsg", kResource, kPtr, kFlags),
    MakeEntry(297, "recvmsg", kResource, kPtr, kFlags),
    MakeEntry(298, "semop", kIpcResource, kArray, kLen1),
    MakeEntry(299, "semget", kIpcResource, kFlags, kFlags),
    MakeEntry(300, "semctl", kIpcResource, kFlags, kSubcommand, kArray),
    MakeEntry(301, "msgsnd", kIpcResource, kPtr, kLen1, kFlags),
    MakeEntry(302, "msgrcv", kIpcResource, kPtr, kLen1, kFlags, kFlags),
    MakeEntry(303, "msgget", kIpcResource, kFlags),
    MakeEntry(304, "msgctl", kIpcResource, kSubcommand, kArray),
    MakeEntry(305, "shmat", kIpcResource, kPtr, kFlags),
    MakeEntry(306, "shmdt", kSharedAddress),
    MakeEntry(307, "shmget", kInt, kLen3, kFlags, kPtr),
    MakeEntry(308, "shmctl", kIpcResource, kSubcommand, kArray),
    MakeEntry(309, "add_key", kString, kPtr, kArray, kLen2, kStruct),
    MakeEntry(310, "request_key", kString, kPtr, kString, kStruct),
    MakeEntry(311, "keyctl", kInt, kInt, kInt, kInt, kInt),
    MakeEntry(312, "semtimedop", kIpcResource, kArray, kLen1, kPtr),
    MakeEntry(313, "vserver", kInt, kInt, kInt, kInt),
    MakeEntry(314, "ioprio_set", kFlags, kPid, kFlags),
    MakeEntry(315, "ioprio_get", kFlags, kUid),
    MakeEntry(316, "inotify_init"),
    MakeEntry(317, "inotify_add_watch", kResource, kPath, kFlags),
    MakeEntry(318, "inotify_rm_watch", kResource, kResource),
    MakeEntry(319, "mbind", kPtr, kLen0, kFlags, kPtr, kInt, kFlags),
    MakeEntry(320, "get_mempolicy", kPtr, kPtr, kInt, kPtr, kFlags),
    MakeEntry(321, "set_mempolicy", kFlags, kPtr, kInt),
    MakeEntry(322, "openat", kResource, kPath, kFlags, kFlags),
    MakeEntry(323, "mkdirat", kResource, kPath, kFlags),
    MakeEntry(324, "mknodat", kResource, kPath, kFlags, kInt),
    MakeEntry(325, "fchownat", kResource, kPath, kUid, kGid, kFlags),
    MakeEntry(326, "futimesat", kResource, kPath, kPtr),
    MakeEntry(327, "fstatat64", kInt, kPath, kPtr, kFlags),
    MakeEntry(328, "unlinkat", kResource, kPath, kFlags),
    MakeEntry(329, "renameat", kResource, kPath, kResource, kPath),
    MakeEntry(330, "linkat", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(331, "symlinkat", kPath, kResource, kPath),
    MakeEntry(332, "readlinkat", kResource, kPath, kArray, kLen2),
    MakeEntry(333, "fchmodat", kResource, kPath, kFlags),
    MakeEntry(334, "faccessat", kResource, kPath, kFlags),
    MakeEntry(335, "pselect6", kLen1, kPtr, kPtr, kPtr, kPtr, kPtr),
    MakeEntry(336, "ppoll", kPollFdArray, kLen0, kPtr, kPtr, kLen3),
    MakeEntry(337, "unshare", kFlags),
    MakeEntry(338, "set_robust_list", kPtr, kLen0),
    MakeEntry(339, "get_robust_list", kPid, kPtr, kPtr),
    MakeEntry(340, "splice", kResource, kPtr, kResource, kPtr, kInt, kFlags),
    MakeEntry(342, "tee", kResource, kResource, kInt, kFlags),
    MakeEntry(343, "vmsplice", kResource, kArray, kLen1, kFlags),
    MakeEntry(344, "move_pages", kPid, kLen2, kArray, kArray, kArray, kFlags),
    MakeEntry(345, "getcpu", kPtr, kPtr),
    MakeEntry(346, "epoll_pwait", kResource, kArray, kLen1, kInt, kPtr, kLen4),
    MakeEntry(347, "kexec_load", kInt, kLen2, kArray, kFlags),
    MakeEntry(348, "utimensat", kResource, kPath, kPtr, kFlags),
    MakeEntry(349, "signalfd", kResource, kPtr, kLen1),
    MakeEntry(350, "timerfd_create", kFlags, kFlags),
    MakeEntry(351, "eventfd", kInt),
    MakeEntry(352, "fallocate", kResource, kFlags, kInt, kInt),
    MakeEntry(353, "timerfd_settime", kResource, kFlags, kPtr, kPtr),
    MakeEntry(354, "timerfd_gettime", kResource, kPtr),
    MakeEntry(355, "signalfd4", kResource, kPtr, kLen1, kFlags),
    MakeEntry(356, "eventfd2", kInt, kFlags),
    MakeEntry(357, "epoll_create1", kFlags),
    MakeEntry(358, "dup3", kResource, kResource, kFlags),
    MakeEntry(359, "pipe2", kPtr, kFlags),
    MakeEntry(360, "inotify_init1", kFlags),
    MakeEntry(361, "preadv", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(362, "pwritev", kResource, kArray, kLen1, kInt, kInt),
    MakeEntry(363, "rt_tgsigqueueinfo", kPid, kPid, kSignal, kPtr),
    MakeEntry(364, "perf_event_open", kPtr, kPid, kInt, kResource, kFlags),
    MakeEntry(365, "recvmmsg", kResource, kArray, kLen1, kFlags, kPtr),
    MakeEntry(366, "accept4", kResource, kPtr, kPtr, kFlags),
    MakeEntry(367, "fanotify_init", kFlags, kFlags),
    MakeEntry(368, "fanotify_mark", kResource, kFlags, kFlags, kResource,
              kPath),
    MakeEntry(369, "prlimit64", kPid, kFlags, kPtr, kPtr),
    MakeEntry(370, "name_to_handle_at", kResource, kPath, kPtr, kPtr, kFlags),
    MakeEntry(371, "open_by_handle_at", kResource, kPtr, kFlags),
    MakeEntry(372, "clock_adjtime", kFlags, kPtr),
    MakeEntry(373, "syncfs", kResource),
    MakeEntry(374, "sendmmsg", kResource, kArray, kLen1, kFlags),
    MakeEntry(375, "setns", kResource, kFlags),
    MakeEntry(376, "process_vm_readv", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(377, "process_vm_writev", kPid, kArray, kLen1, kArray, kLen3,
              kInt),
    MakeEntry(378, "kcmp", kPid, kPid, kFlags, kResource, kResource),
    MakeEntry(379, "finit_module", kResource, kString, kFlags),
    MakeEntry(380, "sched_setattr", kPid, kPtr, kInt),
    MakeEntry(381, "sched_getattr", kPid, kPtr, kLen1, kInt),
    MakeEntry(382, "renameat2", kResource, kPath, kResource, kPath, kFlags),
    MakeEntry(383, "seccomp", kInt, kFlags, kPtr),
    MakeEntry(384, "getrandom", kArray, kLen0, kFlags),
    MakeEntry(385, "memfd_create", kString, kFlags),
    MakeEntry(386, "bpf", kSubcommand, kPtr, kLen1),
    MakeEntry(387, "execveat", kResource, kPath, kArray, kArray, kFlags),
    MakeEntry(388, "userfaultfd", kFlags),
    MakeEntry(389, "membarrier", kSubcommand, kFlags),
    MakeEntry(390, "mlock2", kPtr, kLen0, kFlags),
    MakeEntry(391, "copy_file_range", kResource, kPtr, kResource, kPtr, kInt,
              kFlags),
    MakeEntry(392, "preadv2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(393, "pwritev2", kResource, kArray, kLen1, kInt, kInt, kFlags),
    MakeEntry(400, "migrate_pages", kPid, kInt, kPtr, kPtr),
    MakeEntry(401, "kexec_file_load", kInt, kInt, kInt, kString, kInt),
    MakeEntry(435, "clone3", kPtr, kLen0),
    MakeEntry(436, "close_range", kResource, kResource, kFlags),
    MakeEntry(437, "openat2", kResource, kPath, kPtr, kLen2),
    MakeEntry(438, "pidfd_getfd", kResource, kResource, kInt),
    MakeEntry(439, "faccessat2", kResource, kPath, kFlags, kFlags),
    MakeEntry(440, "process_madvise", kResource, kArray, kLen1, kFlags, kInt),
    MakeEntry(441, "epoll_pwait2", kResource, kArray, kLen1, kPtr, kPtr, kLen4),
    MakeEntry(442, "mount_setattr", kResource, kPath, kFlags, kPtr, kLen3),
    MakeEntry(443, "quotactl_fd", UnknownArguments()),
    MakeEntry(444, "landlock_create_ruleset", kPtr, kLen0, kInt),
    MakeEntry(445, "landlock_add_rule", kResource, kInt, kPtr, kInt),
    MakeEntry(446, "landlock_restrict_self", kResource, kInt),
    MakeEntry(448, "process_mrelease", kResource, kInt),
    MakeEntry(449, "futex_waitv", kArray, kLen0, kInt, kPtr, kFlags),
    MakeEntry(450, "set_mempolicy_home_node", kPtr, kLen0, kInt, kInt),
    MakeEntry(451, "cachestat", kResource, kPtr, kPtr, kInt),
    MakeEntry(452, "fchmodat2", kInt, kPath, kInt, kInt),
    MakeEntry(453, "map_shadow_stack", kPtr, kLen0, kFlags),
    MakeEntry(454, "futex_wake", UnknownArguments()),
    MakeEntry(455, "futex_wait", UnknownArguments()),
    MakeEntry(456, "futex_requeue", UnknownArguments()),
    MakeEntry(457, "statmount", UnknownArguments()),
    MakeEntry(458, "listmount", UnknownArguments()),
    MakeEntry(459, "lsm_get_self_attr", UnknownArguments()),
    MakeEntry(460, "lsm_set_self_attr", UnknownArguments()),
    MakeEntry(461, "lsm_list_modules", UnknownArguments()),
    MakeEntry(0xf0001, "ARM_breakpoint", UnknownArguments()),
    MakeEntry(0xf0002, "ARM_cacheflush", UnknownArguments()),
    MakeEntry(0xf0003, "ARM_usr26", UnknownArguments()),
    MakeEntry(0xf0004, "ARM_usr32", UnknownArguments()),
    MakeEntry(0xf0005, "ARM_set_tls", UnknownArguments()),
    // clang-format on
};

static_assert(IsSorted(kSyscallDataArm32, SyscallTable::Entry::BySyscallNr),
              "Syscalls should be sorted");

}  // namespace
}  // namespace syscalls

SyscallTable SyscallTable::get(sapi::cpu::Architecture arch) {
  switch (arch) {
    case sapi::cpu::kX8664:
      return SyscallTable(syscalls::kSyscallDataX8664);
    case sapi::cpu::kX86:
      return SyscallTable(syscalls::kSyscallDataX8632);
    case sapi::cpu::kPPC64LE:
      return SyscallTable(syscalls::kSyscallDataPPC64LE);
    case sapi::cpu::kArm64:
      return SyscallTable(syscalls::kSyscallDataArm64);
    case sapi::cpu::kArm:
      return SyscallTable(syscalls::kSyscallDataArm32);
    default:
      return SyscallTable();
  }
}

}  // namespace sandbox2
